From 4083e46f475cd3026a3c65a1e46c4b73d5c22513 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 13:14:38 +0000 Subject: [PATCH 01/22] oid: provide type lookups by enum value or name --- src/libgit2/oid.h | 41 ++++++++++++++++++++++++++++++++++++++++ tests/libgit2/core/oid.c | 19 +++++++++++++++++++ 2 files changed, 60 insertions(+) diff --git a/src/libgit2/oid.h b/src/libgit2/oid.h index d775e180b..7b6b09d8b 100644 --- a/src/libgit2/oid.h +++ b/src/libgit2/oid.h @@ -66,6 +66,47 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type) return 0; } +GIT_INLINE(const char *) git_oid_type_name(git_oid_t type) +{ + switch (type) { + case GIT_OID_SHA1: + return "sha1"; + +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + return "sha256"; +#endif + } + + return "unknown"; +} + +GIT_INLINE(git_oid_t) git_oid_type_fromstr(const char *name) +{ + if (strcmp(name, "sha1") == 0) + return GIT_OID_SHA1; + +#ifdef GIT_EXPERIMENTAL_SHA256 + if (strcmp(name, "sha256") == 0) + return GIT_OID_SHA256; +#endif + + return 0; +} + +GIT_INLINE(git_oid_t) git_oid_type_fromstrn(const char *name, size_t len) +{ + if (len == CONST_STRLEN("sha1") && strncmp(name, "sha1", len) == 0) + return GIT_OID_SHA1; + +#ifdef GIT_EXPERIMENTAL_SHA256 + if (len == CONST_STRLEN("sha256") && strncmp(name, "sha256", len) == 0) + return GIT_OID_SHA256; +#endif + + return 0; +} + GIT_INLINE(git_hash_algorithm_t) git_oid_algorithm(git_oid_t type) { switch (type) { diff --git a/tests/libgit2/core/oid.c b/tests/libgit2/core/oid.c index 90fb37514..a405b3344 100644 --- a/tests/libgit2/core/oid.c +++ b/tests/libgit2/core/oid.c @@ -192,3 +192,22 @@ void test_core_oid__fmt_substr_sha1(void) git_oid_fmt_substr(buf, &id_sha1, 5, 6); cl_assert_equal_s(buf, "12eea6"); } + +void test_core_oid__type_lookup(void) +{ + cl_assert_equal_i(GIT_OID_SHA1, git_oid_type_fromstr("sha1")); + cl_assert_equal_i(GIT_OID_SHA1, git_oid_type_fromstrn("sha1...", 4)); + cl_assert_equal_s("sha1", git_oid_type_name(GIT_OID_SHA1)); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_assert_equal_i(GIT_OID_SHA256, git_oid_type_fromstr("sha256")); + cl_assert_equal_i(GIT_OID_SHA256, git_oid_type_fromstrn("sha256...", 6)); + cl_assert_equal_s("sha256", git_oid_type_name(GIT_OID_SHA256)); +#endif + + cl_assert_equal_i(0, git_oid_type_fromstr("sha42")); + cl_assert_equal_i(0, git_oid_type_fromstrn("sha1", 3)); + cl_assert_equal_i(0, git_oid_type_fromstrn("sha1...", 5)); + cl_assert_equal_s("unknown", git_oid_type_name(0)); + cl_assert_equal_s("unknown", git_oid_type_name(42)); +} From acb00e4eae66bfed84046bccb60bf59707fe9626 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 19 Sep 2022 10:39:58 -0400 Subject: [PATCH 02/22] repo: understand the `objectformat` extension Teach the repository about the `objectformat` extension, supporting `sha1` always and `sha256` when the experimental sha256 support is active. --- include/git2/repository.h | 8 ++++ src/libgit2/repository.c | 50 +++++++++++++++++++--- src/libgit2/repository.h | 1 + tests/libgit2/core/opts.c | 15 ++++--- tests/libgit2/repo/objectformat.c | 69 +++++++++++++++++++++++++++++++ 5 files changed, 132 insertions(+), 11 deletions(-) create mode 100644 tests/libgit2/repo/objectformat.c diff --git a/include/git2/repository.h b/include/git2/repository.h index c87f3c962..9b56599d7 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -949,6 +949,14 @@ GIT_EXTERN(int) git_repository_ident(const char **name, const char **email, cons */ GIT_EXTERN(int) git_repository_set_ident(git_repository *repo, const char *name, const char *email); +/** + * Gets the object type used by this repository. + * + * @param repo the repository + * @return the object id type + */ +GIT_EXTERN(git_oid_t) git_repository_oid_type(git_repository *repo); + /** @} */ GIT_END_DECL #endif diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index df41f581c..5d51be6b7 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -67,6 +67,7 @@ static const struct { static int check_repositoryformatversion(int *version, git_config *config); static int check_extensions(git_config *config, int version); static int load_global_config(git_config **config); +static int load_objectformat(git_repository *repo, git_config *config); #define GIT_COMMONDIR_FILE "commondir" #define GIT_GITDIR_FILE "gitdir" @@ -240,7 +241,7 @@ GIT_INLINE(int) validate_repo_path(git_str *path) */ static size_t suffix_len = CONST_STRLEN("objects/pack/pack-.pack.lock") + - GIT_OID_SHA1_HEXSIZE; + GIT_OID_MAX_HEXSIZE; return git_fs_path_validate_str_length_with_suffix( path, suffix_len); @@ -1030,6 +1031,13 @@ int git_repository_open_ext( goto cleanup; } + if (version > 0) { + if ((error = load_objectformat(repo, config)) < 0) + goto cleanup; + } else { + repo->oid_type = GIT_OID_SHA1; + } + /* * Ensure that the git directory and worktree are * owned by the current user. @@ -1549,7 +1557,8 @@ static int check_repositoryformatversion(int *version, git_config *config) } static const char *builtin_extensions[] = { - "noop" + "noop", + "objectformat" }; static git_vector user_extensions = GIT_VECTOR_INIT; @@ -1613,6 +1622,32 @@ static int check_extensions(git_config *config, int version) return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL); } +static int load_objectformat(git_repository *repo, git_config *config) +{ + git_config_entry *entry = NULL; + int error; + + if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) { + if (error == GIT_ENOTFOUND) { + repo->oid_type = GIT_OID_SHA1; + git_error_clear(); + error = 0; + } + + goto done; + } + + if ((repo->oid_type = git_oid_type_fromstr(entry->value)) == 0) { + git_error_set(GIT_ERROR_REPOSITORY, + "unknown object format '%s'", entry->value); + error = GIT_EINVALID; + } + +done: + git_config_entry_free(entry); + return error; +} + int git_repository__extensions(char ***out, size_t *out_len) { git_vector extensions; @@ -2922,14 +2957,14 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head { git_filebuf file = GIT_FILEBUF_INIT; git_str file_path = GIT_STR_INIT; - char orig_head_str[GIT_OID_SHA1_HEXSIZE]; + char orig_head_str[GIT_OID_MAX_HEXSIZE]; int error = 0; git_oid_fmt(orig_head_str, orig_head); if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 && (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 && - (error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_SHA1_HEXSIZE, orig_head_str)) == 0) + (error = git_filebuf_printf(&file, "%.*s\n", (int)git_oid_hexsize(repo->oid_type), orig_head_str)) == 0) error = git_filebuf_commit(&file); if (error < 0) @@ -3042,7 +3077,7 @@ int git_repository_hashfile( goto cleanup; } - error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, GIT_OID_SHA1, fl); + error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, repo->oid_type, fl); cleanup: if (fd >= 0) @@ -3389,3 +3424,8 @@ int git_repository_submodule_cache_clear(git_repository *repo) repo->submodule_cache = NULL; return error; } + +git_oid_t git_repository_oid_type(git_repository *repo) +{ + return repo ? repo->oid_type : 0; +} diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index a488f2bf2..b1e212a32 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -153,6 +153,7 @@ struct git_repository { unsigned is_bare:1; unsigned is_worktree:1; + git_oid_t oid_type; unsigned int lru_counter; diff --git a/tests/libgit2/core/opts.c b/tests/libgit2/core/opts.c index e8f65d510..486ff58c6 100644 --- a/tests/libgit2/core/opts.c +++ b/tests/libgit2/core/opts.c @@ -34,8 +34,9 @@ void test_core_opts__extensions_query(void) cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 1); + cl_assert_equal_sz(out.count, 2); cl_assert_equal_s("noop", out.strings[0]); + cl_assert_equal_s("objectformat", out.strings[1]); git_strarray_dispose(&out); } @@ -48,9 +49,10 @@ void test_core_opts__extensions_add(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 2); + cl_assert_equal_sz(out.count, 3); cl_assert_equal_s("noop", out.strings[0]); - cl_assert_equal_s("foo", out.strings[1]); + cl_assert_equal_s("objectformat", out.strings[1]); + cl_assert_equal_s("foo", out.strings[2]); git_strarray_dispose(&out); } @@ -63,9 +65,10 @@ void test_core_opts__extensions_remove(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in))); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out)); - cl_assert_equal_sz(out.count, 2); - cl_assert_equal_s("bar", out.strings[0]); - cl_assert_equal_s("baz", out.strings[1]); + cl_assert_equal_sz(out.count, 3); + cl_assert_equal_s("objectformat", out.strings[0]); + cl_assert_equal_s("bar", out.strings[1]); + cl_assert_equal_s("baz", out.strings[2]); git_strarray_dispose(&out); } diff --git a/tests/libgit2/repo/objectformat.c b/tests/libgit2/repo/objectformat.c new file mode 100644 index 000000000..3518115f4 --- /dev/null +++ b/tests/libgit2/repo/objectformat.c @@ -0,0 +1,69 @@ +#include "clar_libgit2.h" +#include "futils.h" +#include "sysdir.h" +#include "repository.h" +#include + +git_repository *repo; +git_config *config; + +void test_repo_objectformat__initialize(void) +{ + repo = cl_git_sandbox_init("empty_bare.git"); + + cl_git_pass(git_repository_config(&config, repo)); + cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 1)); +} + +void test_repo_objectformat__cleanup(void) +{ + git_config_free(config); + cl_git_sandbox_cleanup(); +} + +void test_repo_objectformat__unspecified(void) +{ + git_repository *other; + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(other)); + git_repository_free(other); +} + +void test_repo_objectformat__sha1(void) +{ + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "sha1")); + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(other)); + git_repository_free(other); +} + +void test_repo_objectformat__sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "sha256")); + + cl_git_pass(git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_i(GIT_OID_SHA256, git_repository_oid_type(other)); + git_repository_free(other); +#endif +} + +void test_repo_objectformat__invalid(void) +{ + git_repository *other; + + cl_git_pass(git_config_set_string(config, "extensions.objectformat", "bogus")); + + cl_git_fail_with(GIT_EINVALID, git_repository_open(&other, "empty_bare.git")); + cl_assert_equal_s("unknown object format 'bogus'", git_error_last()->message); + git_repository_free(other); +} + From 3dfc12d5e210a6e15c7c54f3514eeeb12fb2108a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 13:07:23 +0000 Subject: [PATCH 03/22] repo: internal setter for `objectformat` Provide an internal function to set the repository's `objectformat`, both in the internal object and in the configuration. --- src/libgit2/repository.c | 30 ++++++++++++++++++++++++++++++ src/libgit2/repository.h | 8 ++++++++ 2 files changed, 38 insertions(+) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 5d51be6b7..9c55aaca5 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1648,6 +1648,36 @@ done: return error; } +int git_repository__set_objectformat( + git_repository *repo, + git_oid_t oid_type) +{ + git_config *cfg; + + /* + * Older clients do not necessarily understand the + * `objectformat` extension, even when it's set to an + * object format that they understand (SHA1). Do not set + * the objectformat extension unless we're not using the + * default object format. + */ + if (oid_type == GIT_OID_DEFAULT) + return 0; + + if (git_repository_config__weakptr(&cfg, repo) < 0) + return -1; + + if (git_config_set_int32(cfg, + "core.repositoryformatversion", 1) < 0 || + git_config_set_string(cfg, "extensions.objectformat", + git_oid_type_name(oid_type)) < 0) + return -1; + + repo->oid_type = oid_type; + + return 0; +} + int git_repository__extensions(char ***out, size_t *out_len) { git_vector extensions; diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h index b1e212a32..75380ae53 100644 --- a/src/libgit2/repository.h +++ b/src/libgit2/repository.h @@ -257,4 +257,12 @@ int git_repository__extensions(char ***out, size_t *out_len); int git_repository__set_extensions(const char **extensions, size_t len); void git_repository__free_extensions(void); +/* + * Set the object format (OID type) for a repository; this will set + * both the configuration and the internal value for the oid type. + */ +int git_repository__set_objectformat( + git_repository *repo, + git_oid_t oid_type); + #endif From 366973f3785b7a2cf95a118fc4e13210ca277529 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 14:32:32 +0000 Subject: [PATCH 04/22] repo: don't overwrite repo format version on reinit Ensure that we maintain the `core.repositoryFormatVersion` value instead of always overwriting it with the default. --- src/libgit2/repository.c | 24 ++++++++++++++++-------- tests/libgit2/repo/init.c | 35 +++++++++++++++++++++++++++-------- 2 files changed, 43 insertions(+), 16 deletions(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 9c55aaca5..043cfd1fd 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -76,8 +76,8 @@ static int load_objectformat(git_repository *repo, git_config *config); #define GIT_BRANCH_DEFAULT "master" -#define GIT_REPO_VERSION 0 -#define GIT_REPO_MAX_VERSION 1 +#define GIT_REPO_VERSION_DEFAULT 0 +#define GIT_REPO_VERSION_MAX 1 git_str git_repository__reserved_names_win32[] = { { DOT_GIT, 0, CONST_STRLEN(DOT_GIT) }, @@ -1016,7 +1016,8 @@ int git_repository_open_ext( if (error < 0 && error != GIT_ENOTFOUND) goto cleanup; - if (config && (error = check_repositoryformatversion(&version, config)) < 0) + if (config && + (error = check_repositoryformatversion(&version, config)) < 0) goto cleanup; if ((error = check_extensions(config, version)) < 0) @@ -1539,6 +1540,7 @@ static int check_repositoryformatversion(int *version, git_config *config) int error; error = git_config_get_int32(version, config, "core.repositoryformatversion"); + /* git ignores this if the config variable isn't there */ if (error == GIT_ENOTFOUND) return 0; @@ -1546,10 +1548,15 @@ static int check_repositoryformatversion(int *version, git_config *config) if (error < 0) return -1; - if (GIT_REPO_MAX_VERSION < *version) { + if (*version < 0) { + git_error_set(GIT_ERROR_REPOSITORY, + "invalid repository version %d", *version); + } + + if (GIT_REPO_VERSION_MAX < *version) { git_error_set(GIT_ERROR_REPOSITORY, "unsupported repository version %d; only versions up to %d are supported", - *version, GIT_REPO_MAX_VERSION); + *version, GIT_REPO_VERSION_MAX); return -1; } @@ -1963,12 +1970,13 @@ static int repo_init_config( git_config *config = NULL; bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0); bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0); - int version = 0; + int version = GIT_REPO_VERSION_DEFAULT; if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0) goto cleanup; - if (is_reinit && (error = check_repositoryformatversion(&version, config)) < 0) + if (is_reinit && + (error = check_repositoryformatversion(&version, config)) < 0) goto cleanup; if ((error = check_extensions(config, version)) < 0) @@ -1979,7 +1987,7 @@ static int repo_init_config( goto cleanup; } while (0) SET_REPO_CONFIG(bool, "core.bare", is_bare); - SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION); + SET_REPO_CONFIG(int32, "core.repositoryformatversion", version); if ((error = repo_init_fs_configs( config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0) diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c index adcd9e025..637d4a903 100644 --- a/tests/libgit2/repo/init.c +++ b/tests/libgit2/repo/init.c @@ -142,30 +142,49 @@ void test_repo_init__reinit_bare_repo(void) cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); } -void test_repo_init__reinit_too_recent_bare_repo(void) +void test_repo_init__reinit_nondefault_version(void) { git_config *config; + cl_set_cleanup(&cleanup_repository, "reinit.git"); + /* Initialize the repository */ cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); git_repository_config(&config, g_repo); - /* - * Hack the config of the repository to make it look like it has - * been created by a recenter version of git/libgit2 - */ - cl_git_pass(git_config_set_int32(config, "core.repositoryformatversion", 42)); - + /* Set the config to a supported but not default version */ + cl_repo_set_string(g_repo, "core.repositoryformatversion", "1"); git_config_free(config); git_repository_free(g_repo); g_repo = NULL; /* Try to reinitialize the repository */ - cl_git_fail(git_repository_init(&g_repo, "reinit.git", 1)); + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + cl_assert_equal_i(1, cl_repo_get_int(g_repo, "core.repositoryformatversion")); cl_fixture_cleanup("reinit.git"); } +void test_repo_init__reinit_unsupported_version(void) +{ + cl_set_cleanup(&cleanup_repository, "reinit.git"); + + /* Initialize the repository */ + cl_git_pass(git_repository_init(&g_repo, "reinit.git", 1)); + + /* + * Hack the config of the repository to make it look like it has + * been created by a too new and unsupported version of git/libgit2 + */ + cl_repo_set_string(g_repo, "core.repositoryformatversion", "42"); + git_repository_free(g_repo); + g_repo = NULL; + + /* Try and fail to reinitialize the repository */ + cl_git_fail(git_repository_init(&g_repo, "reinit.git", 1)); + cl_fixture_cleanup("reinit.git"); +} + void test_repo_init__additional_templates(void) { git_str path = GIT_STR_INIT; From f6dbf9c5949e731b928b75090e793150d522afd1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sat, 3 Dec 2022 14:33:11 +0000 Subject: [PATCH 05/22] tests: helpers for getting ints from configuration --- tests/clar/clar_libgit2.c | 19 +++++++++++++++++++ tests/clar/clar_libgit2.h | 3 +++ 2 files changed, 22 insertions(+) diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c index 783b457f9..2ba272706 100644 --- a/tests/clar/clar_libgit2.c +++ b/tests/clar/clar_libgit2.c @@ -476,6 +476,25 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg) return val; } +void cl_repo_set_int(git_repository *repo, const char *cfg, int value) +{ + git_config *config; + cl_git_pass(git_repository_config(&config, repo)); + cl_git_pass(git_config_set_int32(config, cfg, value)); + git_config_free(config); +} + +int cl_repo_get_int(git_repository *repo, const char *cfg) +{ + int val = 0; + git_config *config; + cl_git_pass(git_repository_config(&config, repo)); + if (git_config_get_int32(&val, config, cfg) < 0) + git_error_clear(); + git_config_free(config); + return val; +} + void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value) { git_config *config; diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h index d2d9da0aa..a002a6d14 100644 --- a/tests/clar/clar_libgit2.h +++ b/tests/clar/clar_libgit2.h @@ -231,6 +231,9 @@ void cl_repo_commit_from_index( void cl_repo_set_bool(git_repository *repo, const char *cfg, int value); int cl_repo_get_bool(git_repository *repo, const char *cfg); +void cl_repo_set_int(git_repository *repo, const char *cfg, int value); +int cl_repo_get_int(git_repository *repo, const char *cfg); + void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value); /* set up a fake "home" directory and set libgit2 GLOBAL search path. From 1bde753db4e302f657eb968f7eba178c2bc20205 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:13:32 -0400 Subject: [PATCH 06/22] ci: run sha256 builds during our nightly runs --- .github/workflows/nightly.yml | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 425a6e89a..5a0b7d12b 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -265,10 +265,40 @@ jobs: RUN_INVASIVE_TESTS: true SKIP_PROXY_TESTS: true os: ubuntu-latest + + # Experimental: SHA256 support + - name: "Linux (SHA256, Xenial, Clang, OpenSSL)" + id: xenial-clang-openssl + container: + name: xenial + env: + CC: clang + CMAKE_GENERATOR: Ninja + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + os: ubuntu-latest + - name: "macOS (SHA256)" + id: macos + os: macos-10.15 + env: + CC: clang + CMAKE_OPTIONS: -DREGEX_BACKEND=regcomp_l -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=leaks -DUSE_GSSAPI=ON -DEXPERIMENTAL_SHA256=ON + PKG_CONFIG_PATH: /usr/local/opt/openssl/lib/pkgconfig + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true + setup-script: osx + - name: "Windows (SHA256, amd64, Visual Studio)" + id: windows-amd64-vs + os: windows-2019 + env: + ARCH: amd64 + CMAKE_GENERATOR: Visual Studio 16 2019 + CMAKE_OPTIONS: -A x64 -DWIN32_LEAKCHECK=ON -DDEPRECATE_HARD=ON -DEXPERIMENTAL_SHA256=ON + SKIP_SSH_TESTS: true + SKIP_NEGOTIATE_TESTS: true fail-fast: false - name: "Build ${{ matrix.platform.name }}" env: ${{ matrix.platform.env }} runs-on: ${{ matrix.platform.os }} + name: "Build ${{ matrix.platform.name }}" steps: - name: Check out repository uses: actions/checkout@v3 From 23df884ea7fa1a563865e9548bebe2b3eedd602b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:13:45 -0400 Subject: [PATCH 07/22] tests: add a sha256 repository This is a conversion of the testrepo.git to SHA256 support. --- tests/resources/testrepo_256.git/FETCH_HEAD | 2 + tests/resources/testrepo_256.git/HEAD | 1 + tests/resources/testrepo_256.git/HEAD_TRACKER | 1 + tests/resources/testrepo_256.git/config | 8 + tests/resources/testrepo_256.git/description | 1 + .../hooks/applypatch-msg.sample | 15 + .../testrepo_256.git/hooks/commit-msg.sample | 24 + .../hooks/fsmonitor-watchman.sample | 173 ++ .../testrepo_256.git/hooks/post-update.sample | 8 + .../hooks/pre-applypatch.sample | 14 + .../testrepo_256.git/hooks/pre-commit.sample | 49 + .../hooks/pre-merge-commit.sample | 13 + .../testrepo_256.git/hooks/pre-push.sample | 53 + .../testrepo_256.git/hooks/pre-rebase.sample | 169 ++ .../testrepo_256.git/hooks/pre-receive.sample | 24 + .../hooks/prepare-commit-msg.sample | 42 + .../hooks/push-to-checkout.sample | 78 + .../testrepo_256.git/hooks/update.sample | 128 ++ tests/resources/testrepo_256.git/index | Bin 0 -> 11148 bytes tests/resources/testrepo_256.git/info/exclude | 6 + tests/resources/testrepo_256.git/logs/HEAD | 7 + .../testrepo_256.git/logs/refs/heads/br2 | 2 + .../testrepo_256.git/logs/refs/heads/master | 2 + .../testrepo_256.git/logs/refs/heads/not-good | 1 + .../logs/refs/heads/with-empty-log | 0 .../logs/refs/remotes/origin/HEAD | 1 + .../logs/refs/remotes/test/master | 2 + tests/resources/testrepo_256.git/object-idx | 1700 +++++++++++++++++ ...925bdc34ccdab778bd1d824f5562aaa319c6c8f045 | Bin 0 -> 267 bytes ...6d13866742a9070b56fd0ba9ab8dff828fc36c1f78 | 1 + ...16acdd727ea9364f7d48c55afed2f7dd889804065b | Bin 0 -> 103 bytes ...fcd19f12cc38faf337d10ec03ef4363d1a86f63750 | Bin 0 -> 21 bytes ...ba8801fe9bda46b66593291f5b9f7cd5f8888af12f | 1 + ...7e8ddfc9c8c47820fab5615cc04d904989ce800498 | Bin 0 -> 64 bytes ...4acca4ce4e1ea8508dfd77c24cefd461b65cead09e | Bin 0 -> 92 bytes ...da9be93f4afc2279623bb5b36c9194a660b7623c24 | Bin 0 -> 236 bytes ...50334e36a8015a546f0740bea4505e10d81a946f61 | Bin 0 -> 162 bytes ...08d88e14af624bb07fced6390997a0fa6abdad950a | Bin 0 -> 143 bytes ...e50a12b15f26aace3718749624f008bde68670352a | Bin 0 -> 202 bytes ...8644c307e17d0afe29b55f6488398cb59f13feb2f2 | Bin 0 -> 238 bytes ...0efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 | Bin 0 -> 19 bytes ...830c2134815a31d9629e6aa9773338fedaab90976b | 1 + ...f2f30d79af178374166daeceefbf11e2f058d30d60 | Bin 0 -> 21 bytes ...eeca6bfffd9a0fe641784db85de2eb0f57b7553869 | Bin 0 -> 106 bytes ...89aa396d10f71c69e168d5c48ea23de59734ec3ab1 | Bin 0 -> 38 bytes ...917e3db8fde0045ee66305fd5e634b0c793c536a1b | 1 + ...e3b1e9a7dcda1185436fe141f7749120a303721813 | Bin 0 -> 15 bytes ...31b132e66ef18f564d41efb055804ec1dd28efb3f5 | Bin 0 -> 28 bytes ...2170996ce459d39e3a441e9759b635b0bc4ecc43fd | Bin 0 -> 57 bytes ...8c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b | Bin 0 -> 64 bytes ...44523eb1ddeeef4bce03e35864640b452f84d26848 | 1 + ...635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f | 3 + ...39b79f964c293db8620d679ea3596673c8a326446e | Bin 0 -> 157 bytes ...492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 | Bin 0 -> 24 bytes ...b8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 | Bin 0 -> 107 bytes ...e660a4d510603c3f36e782a1a32ebd0388db6411ed | Bin 0 -> 181 bytes ...8aeb2c7811556538e7673e4b325307c71685fbf5b6 | Bin 0 -> 108 bytes ...417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f | Bin 0 -> 141 bytes ...bccadee60065d8664a9af7648a1455100c4f772e1c | 2 + ...da9b3179f2419717275e3bfd2055b303489dbbfa47 | 1 + ...908dc44452ed38911cffa54ccc06076f30a1ffb1bf | Bin 0 -> 108 bytes ...c5d3f23bac1dded688b2bd314cc32b7f157e100724 | 1 + ...0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe | Bin 0 -> 137 bytes ...c294c441d08b89b455903c0c14e9b16587fec081f5 | Bin 0 -> 188 bytes ...cddea4259aea6b2961eb0822bd2c0c3f6029030045 | Bin 0 -> 18 bytes ...db7fc3a850e94f8c5ac1d71b9afa365a89005aff54 | Bin 0 -> 221 bytes ...8cc3cf4602c270a369beebc7d0b67238897bbc426b | 1 + ...24297e83e4a285f58bf5eabb1db270351388603c95 | Bin 0 -> 244 bytes ...ea61f40c14bdfc5b101b60fde4f44b58dd06667640 | Bin 0 -> 63 bytes ...3fdeed5502fd56b182af01b7740d297a24459333c5 | Bin 0 -> 26 bytes ...a3497ade7f62d2cd818bf388775cfa721de4068ebd | Bin 0 -> 54 bytes ...4ebf05e11d9c591b04cfdaff7cc860310356d71827 | 1 + ...82c5c09c22053675e2db24ea6b4b28cc75e9c10890 | Bin 0 -> 37 bytes ...a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 | Bin 0 -> 190 bytes ...157ee4aad97814279fe500340eb3465797cbd3be23 | Bin 0 -> 23 bytes ...444b12c412210e9689c17e51bfc318ce4bb4360f19 | Bin 0 -> 57 bytes ...aaa96359f304c3dc97e95f336269ed474ea846ada5 | Bin 0 -> 198 bytes ...411d955520e0375fcbbcc14b7636a70f7536c32ef6 | 2 + ...787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 | Bin 0 -> 182 bytes ...621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 | Bin 0 -> 187 bytes ...abfa899655d1b00e6529101a40d42f6acb059dff9f | Bin 0 -> 21 bytes ...3d137b654c602721c469c1b0a58e7e95647a9cf1c0 | 3 + ...8e201abb820a414de03eb63c065b06a2ab37d3f5ca | 1 + ...d3d4a80ced03101555e1fd8913b3544026c0717d4f | Bin 0 -> 181 bytes ...a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 | Bin 0 -> 21 bytes ...55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 | Bin 0 -> 157 bytes ...441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 | Bin 0 -> 192 bytes ...24c75107423d5773066922ea5e55eaeb6490979562 | Bin 0 -> 157 bytes ...6e7643653c03e7f91faa27b767e3eb8225f0f6.idx | Bin 0 -> 1336 bytes ...e7643653c03e7f91faa27b767e3eb8225f0f6.pack | Bin 0 -> 569 bytes ...791b9b270067124b2609019b74f33f256f33fa.idx | Bin 0 -> 66216 bytes ...91b9b270067124b2609019b74f33f256f33fa.pack | Bin 0 -> 562646 bytes ...80b24ee981cf102db76764c383f9b87935d0d3.idx | Bin 0 -> 1336 bytes ...0b24ee981cf102db76764c383f9b87935d0d3.pack | Bin 0 -> 612 bytes tests/resources/testrepo_256.git/packed-refs | 3 + .../refs/blobs/annotated_tag_to_blob | 1 + .../resources/testrepo_256.git/refs/heads/br2 | 1 + .../testrepo_256.git/refs/heads/cannot-fetch | 1 + .../testrepo_256.git/refs/heads/chomped | 1 + .../testrepo_256.git/refs/heads/haacked | 1 + .../testrepo_256.git/refs/heads/master | 1 + .../testrepo_256.git/refs/heads/not-good | 1 + .../testrepo_256.git/refs/heads/packed-test | 1 + .../testrepo_256.git/refs/heads/subtrees | 1 + .../testrepo_256.git/refs/heads/test | 1 + .../testrepo_256.git/refs/heads/track-local | 1 + .../testrepo_256.git/refs/heads/trailing | 1 + .../refs/heads/with-empty-log | 1 + .../testrepo_256.git/refs/notes/fanout | 1 + .../testrepo_256.git/refs/remotes/test/master | 1 + .../refs/tags/annotated_tag_to_blob | 1 + .../testrepo_256.git/refs/tags/e90810b | 1 + .../testrepo_256.git/refs/tags/hard_tag | 1 + .../testrepo_256.git/refs/tags/point_to_blob | 1 + .../testrepo_256.git/refs/tags/taggerless | 1 + .../resources/testrepo_256.git/refs/tags/test | 1 + .../testrepo_256.git/refs/tags/wrapped_tag | 1 + 117 files changed, 2569 insertions(+) create mode 100644 tests/resources/testrepo_256.git/FETCH_HEAD create mode 100644 tests/resources/testrepo_256.git/HEAD create mode 100644 tests/resources/testrepo_256.git/HEAD_TRACKER create mode 100644 tests/resources/testrepo_256.git/config create mode 100644 tests/resources/testrepo_256.git/description create mode 100755 tests/resources/testrepo_256.git/hooks/applypatch-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/commit-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample create mode 100755 tests/resources/testrepo_256.git/hooks/post-update.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-applypatch.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-commit.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-push.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-rebase.sample create mode 100755 tests/resources/testrepo_256.git/hooks/pre-receive.sample create mode 100755 tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample create mode 100755 tests/resources/testrepo_256.git/hooks/push-to-checkout.sample create mode 100755 tests/resources/testrepo_256.git/hooks/update.sample create mode 100644 tests/resources/testrepo_256.git/index create mode 100644 tests/resources/testrepo_256.git/info/exclude create mode 100644 tests/resources/testrepo_256.git/logs/HEAD create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/br2 create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/master create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/not-good create mode 100644 tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log create mode 100644 tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD create mode 100644 tests/resources/testrepo_256.git/logs/refs/remotes/test/master create mode 100644 tests/resources/testrepo_256.git/object-idx create mode 100644 tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 create mode 100644 tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 create mode 100644 tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b create mode 100644 tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 create mode 100644 tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f create mode 100644 tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 create mode 100644 tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e create mode 100644 tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 create mode 100644 tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 create mode 100644 tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a create mode 100644 tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a create mode 100644 tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 create mode 100644 tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 create mode 100644 tests/resources/testrepo_256.git/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b create mode 100644 tests/resources/testrepo_256.git/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 create mode 100644 tests/resources/testrepo_256.git/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 create mode 100644 tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 create mode 100644 tests/resources/testrepo_256.git/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b create mode 100644 tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 create mode 100644 tests/resources/testrepo_256.git/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 create mode 100644 tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd create mode 100644 tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b create mode 100644 tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 create mode 100644 tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f create mode 100644 tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e create mode 100644 tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 create mode 100644 tests/resources/testrepo_256.git/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 create mode 100644 tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed create mode 100644 tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 create mode 100644 tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f create mode 100644 tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c create mode 100644 tests/resources/testrepo_256.git/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 create mode 100644 tests/resources/testrepo_256.git/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf create mode 100644 tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 create mode 100644 tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe create mode 100644 tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 create mode 100644 tests/resources/testrepo_256.git/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 create mode 100644 tests/resources/testrepo_256.git/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 create mode 100644 tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b create mode 100644 tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 create mode 100644 tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 create mode 100644 tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 create mode 100644 tests/resources/testrepo_256.git/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd create mode 100644 tests/resources/testrepo_256.git/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 create mode 100644 tests/resources/testrepo_256.git/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 create mode 100644 tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 create mode 100644 tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 create mode 100644 tests/resources/testrepo_256.git/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 create mode 100644 tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 create mode 100644 tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 create mode 100644 tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 create mode 100644 tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 create mode 100644 tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f create mode 100644 tests/resources/testrepo_256.git/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 create mode 100644 tests/resources/testrepo_256.git/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca create mode 100644 tests/resources/testrepo_256.git/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f create mode 100644 tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 create mode 100644 tests/resources/testrepo_256.git/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 create mode 100644 tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 create mode 100644 tests/resources/testrepo_256.git/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx create mode 100644 tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack create mode 100644 tests/resources/testrepo_256.git/packed-refs create mode 100644 tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/heads/br2 create mode 100644 tests/resources/testrepo_256.git/refs/heads/cannot-fetch create mode 100644 tests/resources/testrepo_256.git/refs/heads/chomped create mode 100644 tests/resources/testrepo_256.git/refs/heads/haacked create mode 100644 tests/resources/testrepo_256.git/refs/heads/master create mode 100644 tests/resources/testrepo_256.git/refs/heads/not-good create mode 100644 tests/resources/testrepo_256.git/refs/heads/packed-test create mode 100644 tests/resources/testrepo_256.git/refs/heads/subtrees create mode 100644 tests/resources/testrepo_256.git/refs/heads/test create mode 100644 tests/resources/testrepo_256.git/refs/heads/track-local create mode 100644 tests/resources/testrepo_256.git/refs/heads/trailing create mode 100644 tests/resources/testrepo_256.git/refs/heads/with-empty-log create mode 100644 tests/resources/testrepo_256.git/refs/notes/fanout create mode 100644 tests/resources/testrepo_256.git/refs/remotes/test/master create mode 100644 tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/tags/e90810b create mode 100644 tests/resources/testrepo_256.git/refs/tags/hard_tag create mode 100644 tests/resources/testrepo_256.git/refs/tags/point_to_blob create mode 100644 tests/resources/testrepo_256.git/refs/tags/taggerless create mode 100644 tests/resources/testrepo_256.git/refs/tags/test create mode 100644 tests/resources/testrepo_256.git/refs/tags/wrapped_tag diff --git a/tests/resources/testrepo_256.git/FETCH_HEAD b/tests/resources/testrepo_256.git/FETCH_HEAD new file mode 100644 index 000000000..4562d9026 --- /dev/null +++ b/tests/resources/testrepo_256.git/FETCH_HEAD @@ -0,0 +1,2 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f branch 'master' of git://example.com/git/testrepo.git +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c not-for-merge branch 'haacked' of git://example.com/git/testrepo.git diff --git a/tests/resources/testrepo_256.git/HEAD b/tests/resources/testrepo_256.git/HEAD new file mode 100644 index 000000000..cb089cd89 --- /dev/null +++ b/tests/resources/testrepo_256.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/master diff --git a/tests/resources/testrepo_256.git/HEAD_TRACKER b/tests/resources/testrepo_256.git/HEAD_TRACKER new file mode 100644 index 000000000..40d876b4c --- /dev/null +++ b/tests/resources/testrepo_256.git/HEAD_TRACKER @@ -0,0 +1 @@ +ref: HEAD diff --git a/tests/resources/testrepo_256.git/config b/tests/resources/testrepo_256.git/config new file mode 100644 index 000000000..c1aac4a03 --- /dev/null +++ b/tests/resources/testrepo_256.git/config @@ -0,0 +1,8 @@ +[core] + repositoryFormatVersion = 1 + filemode = true + bare = true + ignorecase = true + precomposeunicode = true +[extensions] + objectFormat = sha256 diff --git a/tests/resources/testrepo_256.git/description b/tests/resources/testrepo_256.git/description new file mode 100644 index 000000000..498b267a8 --- /dev/null +++ b/tests/resources/testrepo_256.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample b/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample new file mode 100755 index 000000000..a5d7b84a6 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/applypatch-msg.sample @@ -0,0 +1,15 @@ +#!/bin/sh +# +# An example hook script to check the commit log message taken by +# applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. The hook is +# allowed to edit the commit message file. +# +# To enable this hook, rename this file to "applypatch-msg". + +. git-sh-setup +commitmsg="$(git rev-parse --git-path hooks/commit-msg)" +test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} +: diff --git a/tests/resources/testrepo_256.git/hooks/commit-msg.sample b/tests/resources/testrepo_256.git/hooks/commit-msg.sample new file mode 100755 index 000000000..b58d1184a --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/commit-msg.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to check the commit log message. +# Called by "git commit" with one argument, the name of the file +# that has the commit message. The hook should exit with non-zero +# status after issuing an appropriate message if it wants to stop the +# commit. The hook is allowed to edit the commit message file. +# +# To enable this hook, rename this file to "commit-msg". + +# Uncomment the below to add a Signed-off-by line to the message. +# Doing this in a hook is a bad idea in general, but the prepare-commit-msg +# hook is more suited to it. +# +# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" + +# This example catches duplicate Signed-off-by lines. + +test "" = "$(grep '^Signed-off-by: ' "$1" | + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 +} diff --git a/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample b/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample new file mode 100755 index 000000000..14ed0aa42 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/fsmonitor-watchman.sample @@ -0,0 +1,173 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use IPC::Open2; + +# An example hook script to integrate Watchman +# (https://facebook.github.io/watchman/) with git to speed up detecting +# new and modified files. +# +# The hook is passed a version (currently 2) and last update token +# formatted as a string and outputs to stdout a new update token and +# all files that have been modified since the update token. Paths must +# be relative to the root of the working tree and separated by a single NUL. +# +# To enable this hook, rename this file to "query-watchman" and set +# 'git config core.fsmonitor .git/hooks/query-watchman' +# +my ($version, $last_update_token) = @ARGV; + +# Uncomment for debugging +# print STDERR "$0 $version $last_update_token\n"; + +# Check the hook interface version +if ($version ne 2) { + die "Unsupported query-fsmonitor hook version '$version'.\n" . + "Falling back to scanning...\n"; +} + +my $git_work_tree = get_working_dir(); + +my $retry = 1; + +my $json_pkg; +eval { + require JSON::XS; + $json_pkg = "JSON::XS"; + 1; +} or do { + require JSON::PP; + $json_pkg = "JSON::PP"; +}; + +launch_watchman(); + +sub launch_watchman { + my $o = watchman_query(); + if (is_work_tree_watched($o)) { + output_result($o->{clock}, @{$o->{files}}); + } +} + +sub output_result { + my ($clockid, @files) = @_; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # binmode $fh, ":utf8"; + # print $fh "$clockid\n@files\n"; + # close $fh; + + binmode STDOUT, ":utf8"; + print $clockid; + print "\0"; + local $, = "\0"; + print @files; +} + +sub watchman_clock { + my $response = qx/watchman clock "$git_work_tree"/; + die "Failed to get clock id on '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + + return $json_pkg->new->utf8->decode($response); +} + +sub watchman_query { + my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') + or die "open2() failed: $!\n" . + "Falling back to scanning...\n"; + + # In the query expression below we're asking for names of files that + # changed since $last_update_token but not from the .git folder. + # + # To accomplish this, we're using the "since" generator to use the + # recency index to select candidate nodes and "fields" to limit the + # output to file names only. Then we're using the "expression" term to + # further constrain the results. + if (substr($last_update_token, 0, 1) eq "c") { + $last_update_token = "\"$last_update_token\""; + } + my $query = <<" END"; + ["query", "$git_work_tree", { + "since": $last_update_token, + "fields": ["name"], + "expression": ["not", ["dirname", ".git"]] + }] + END + + # Uncomment for debugging the watchman query + # open (my $fh, ">", ".git/watchman-query.json"); + # print $fh $query; + # close $fh; + + print CHLD_IN $query; + close CHLD_IN; + my $response = do {local $/; }; + + # Uncomment for debugging the watch response + # open ($fh, ">", ".git/watchman-response.json"); + # print $fh $response; + # close $fh; + + die "Watchman: command returned no output.\n" . + "Falling back to scanning...\n" if $response eq ""; + die "Watchman: command returned invalid output: $response\n" . + "Falling back to scanning...\n" unless $response =~ /^\{/; + + return $json_pkg->new->utf8->decode($response); +} + +sub is_work_tree_watched { + my ($output) = @_; + my $error = $output->{error}; + if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { + $retry--; + my $response = qx/watchman watch "$git_work_tree"/; + die "Failed to make watchman watch '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + $output = $json_pkg->new->utf8->decode($response); + $error = $output->{error}; + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # close $fh; + + # Watchman will always return all files on the first query so + # return the fast "everything is dirty" flag to git and do the + # Watchman query just to get it over with now so we won't pay + # the cost in git to look up each individual file. + my $o = watchman_clock(); + $error = $output->{error}; + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + output_result($o->{clock}, ("/")); + $last_update_token = $o->{clock}; + + eval { launch_watchman() }; + return 0; + } + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + return 1; +} + +sub get_working_dir { + my $working_dir; + if ($^O =~ 'msys' || $^O =~ 'cygwin') { + $working_dir = Win32::GetCwd(); + $working_dir =~ tr/\\/\//; + } else { + require Cwd; + $working_dir = Cwd::cwd(); + } + + return $working_dir; +} diff --git a/tests/resources/testrepo_256.git/hooks/post-update.sample b/tests/resources/testrepo_256.git/hooks/post-update.sample new file mode 100755 index 000000000..ec17ec193 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/post-update.sample @@ -0,0 +1,8 @@ +#!/bin/sh +# +# An example hook script to prepare a packed repository for use over +# dumb transports. +# +# To enable this hook, rename this file to "post-update". + +exec git update-server-info diff --git a/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample b/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample new file mode 100755 index 000000000..4142082bc --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-applypatch.sample @@ -0,0 +1,14 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed +# by applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-applypatch". + +. git-sh-setup +precommit="$(git rev-parse --git-path hooks/pre-commit)" +test -x "$precommit" && exec "$precommit" ${1+"$@"} +: diff --git a/tests/resources/testrepo_256.git/hooks/pre-commit.sample b/tests/resources/testrepo_256.git/hooks/pre-commit.sample new file mode 100755 index 000000000..e144712c8 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-commit.sample @@ -0,0 +1,49 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git commit" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message if +# it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-commit". + +if git rev-parse --verify HEAD >/dev/null 2>&1 +then + against=HEAD +else + # Initial commit: diff against an empty tree object + against=$(git hash-object -t tree /dev/null) +fi + +# If you want to allow non-ASCII filenames set this variable to true. +allownonascii=$(git config --type=bool hooks.allownonascii) + +# Redirect output to stderr. +exec 1>&2 + +# Cross platform projects tend to avoid non-ASCII filenames; prevent +# them from being added to the repository. We exploit the fact that the +# printable range starts at the space character and ends with tilde. +if [ "$allownonascii" != "true" ] && + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 +then + cat <<\EOF +Error: Attempt to add a non-ASCII file name. + +This can cause problems if you want to work with people on other platforms. + +To be portable it is advisable to rename the file. + +If you know what you are doing you can disable this check using: + + git config hooks.allownonascii true +EOF + exit 1 +fi + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached $against -- diff --git a/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample b/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample new file mode 100755 index 000000000..399eab192 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-merge-commit.sample @@ -0,0 +1,13 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git merge" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message to +# stderr if it wants to stop the merge commit. +# +# To enable this hook, rename this file to "pre-merge-commit". + +. git-sh-setup +test -x "$GIT_DIR/hooks/pre-commit" && + exec "$GIT_DIR/hooks/pre-commit" +: diff --git a/tests/resources/testrepo_256.git/hooks/pre-push.sample b/tests/resources/testrepo_256.git/hooks/pre-push.sample new file mode 100755 index 000000000..4ce688d32 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-push.sample @@ -0,0 +1,53 @@ +#!/bin/sh + +# An example hook script to verify what is about to be pushed. Called by "git +# push" after it has checked the remote status, but before anything has been +# pushed. If this script exits with a non-zero status nothing will be pushed. +# +# This hook is called with the following parameters: +# +# $1 -- Name of the remote to which the push is being done +# $2 -- URL to which the push is being done +# +# If pushing without using a named remote those arguments will be equal. +# +# Information about the commits which are being pushed is supplied as lines to +# the standard input in the form: +# +# +# +# This sample shows how to prevent push of commits where the log message starts +# with "WIP" (work in progress). + +remote="$1" +url="$2" + +zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi +done + +exit 0 diff --git a/tests/resources/testrepo_256.git/hooks/pre-rebase.sample b/tests/resources/testrepo_256.git/hooks/pre-rebase.sample new file mode 100755 index 000000000..6cbef5c37 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-rebase.sample @@ -0,0 +1,169 @@ +#!/bin/sh +# +# Copyright (c) 2006, 2008 Junio C Hamano +# +# The "pre-rebase" hook is run just before "git rebase" starts doing +# its job, and can prevent the command from running by exiting with +# non-zero status. +# +# The hook is called with the following parameters: +# +# $1 -- the upstream the series was forked from. +# $2 -- the branch being rebased (or empty when rebasing the current branch). +# +# This sample shows how to prevent topic branches that are already +# merged to 'next' branch from getting rebased, because allowing it +# would result in rebasing already published history. + +publish=next +basebranch="$1" +if test "$#" = 2 +then + topic="refs/heads/$2" +else + topic=`git symbolic-ref HEAD` || + exit 0 ;# we do not interrupt rebasing detached HEAD +fi + +case "$topic" in +refs/heads/??/*) + ;; +*) + exit 0 ;# we do not interrupt others. + ;; +esac + +# Now we are dealing with a topic branch being rebased +# on top of master. Is it OK to rebase it? + +# Does the topic really exist? +git show-ref -q "$topic" || { + echo >&2 "No such branch $topic" + exit 1 +} + +# Is topic fully merged to master? +not_in_master=`git rev-list --pretty=oneline ^master "$topic"` +if test -z "$not_in_master" +then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 ;# we could allow it, but there is no point. +fi + +# Is topic ever merged to next? If so you should not be rebasing it. +only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` +only_next_2=`git rev-list ^master ${publish} | sort` +if test "$only_next_1" = "$only_next_2" +then + not_in_topic=`git rev-list "^$topic" master` + if test -z "$not_in_topic" + then + echo >&2 "$topic is already up to date with master" + exit 1 ;# we could allow it, but there is no point. + else + exit 0 + fi +else + not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` + /usr/bin/perl -e ' + my $topic = $ARGV[0]; + my $msg = "* $topic has commits already merged to public branch:\n"; + my (%not_in_next) = map { + /^([0-9a-f]+) /; + ($1 => 1); + } split(/\n/, $ARGV[1]); + for my $elem (map { + /^([0-9a-f]+) (.*)$/; + [$1 => $2]; + } split(/\n/, $ARGV[2])) { + if (!exists $not_in_next{$elem->[0]}) { + if ($msg) { + print STDERR $msg; + undef $msg; + } + print STDERR " $elem->[1]\n"; + } + } + ' "$topic" "$not_in_next" "$not_in_master" + exit 1 +fi + +<<\DOC_END + +This sample hook safeguards topic branches that have been +published from being rewound. + +The workflow assumed here is: + + * Once a topic branch forks from "master", "master" is never + merged into it again (either directly or indirectly). + + * Once a topic branch is fully cooked and merged into "master", + it is deleted. If you need to build on top of it to correct + earlier mistakes, a new topic branch is created by forking at + the tip of the "master". This is not strictly necessary, but + it makes it easier to keep your history simple. + + * Whenever you need to test or publish your changes to topic + branches, merge them into "next" branch. + +The script, being an example, hardcodes the publish branch name +to be "next", but it is trivial to make it configurable via +$GIT_DIR/config mechanism. + +With this workflow, you would want to know: + +(1) ... if a topic branch has ever been merged to "next". Young + topic branches can have stupid mistakes you would rather + clean up before publishing, and things that have not been + merged into other branches can be easily rebased without + affecting other people. But once it is published, you would + not want to rewind it. + +(2) ... if a topic branch has been fully merged to "master". + Then you can delete it. More importantly, you should not + build on top of it -- other people may already want to + change things related to the topic as patches against your + "master", so if you need further changes, it is better to + fork the topic (perhaps with the same name) afresh from the + tip of "master". + +Let's look at this example: + + o---o---o---o---o---o---o---o---o---o "next" + / / / / + / a---a---b A / / + / / / / + / / c---c---c---c B / + / / / \ / + / / / b---b C \ / + / / / / \ / + ---o---o---o---o---o---o---o---o---o---o---o "master" + + +A, B and C are topic branches. + + * A has one fix since it was merged up to "next". + + * B has finished. It has been fully merged up to "master" and "next", + and is ready to be deleted. + + * C has not merged to "next" at all. + +We would want to allow C to be rebased, refuse A, and encourage +B to be deleted. + +To compute (1): + + git rev-list ^master ^topic next + git rev-list ^master next + + if these match, topic has not merged in next at all. + +To compute (2): + + git rev-list master..topic + + if this is empty, it is fully merged to "master". + +DOC_END diff --git a/tests/resources/testrepo_256.git/hooks/pre-receive.sample b/tests/resources/testrepo_256.git/hooks/pre-receive.sample new file mode 100755 index 000000000..a1fd29ec1 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/pre-receive.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to make use of push options. +# The example simply echoes all push options that start with 'echoback=' +# and rejects all pushes when the "reject" push option is used. +# +# To enable this hook, rename this file to "pre-receive". + +if test -n "$GIT_PUSH_OPTION_COUNT" +then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" + do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + esac + i=$((i + 1)) + done +fi diff --git a/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample b/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample new file mode 100755 index 000000000..10fa14c5a --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/prepare-commit-msg.sample @@ -0,0 +1,42 @@ +#!/bin/sh +# +# An example hook script to prepare the commit log message. +# Called by "git commit" with the name of the file that has the +# commit message, followed by the description of the commit +# message's source. The hook's purpose is to edit the commit +# message file. If the hook fails with a non-zero status, +# the commit is aborted. +# +# To enable this hook, rename this file to "prepare-commit-msg". + +# This hook includes three examples. The first one removes the +# "# Please enter the commit message..." help message. +# +# The second includes the output of "git diff --name-status -r" +# into the message, just before the "git status" output. It is +# commented because it doesn't cope with --amend or with squashed +# commits. +# +# The third example adds a Signed-off-by line to the message, that can +# still be edited. This is rarely a good idea. + +COMMIT_MSG_FILE=$1 +COMMIT_SOURCE=$2 +SHA1=$3 + +/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" + +# case "$COMMIT_SOURCE,$SHA1" in +# ,|template,) +# /usr/bin/perl -i.bak -pe ' +# print "\n" . `git diff --cached --name-status -r` +# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; +# *) ;; +# esac + +# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" +# if test -z "$COMMIT_SOURCE" +# then +# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" +# fi diff --git a/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample b/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample new file mode 100755 index 000000000..af5a0c001 --- /dev/null +++ b/tests/resources/testrepo_256.git/hooks/push-to-checkout.sample @@ -0,0 +1,78 @@ +#!/bin/sh + +# An example hook script to update a checked-out tree on a git push. +# +# This hook is invoked by git-receive-pack(1) when it reacts to git +# push and updates reference(s) in its repository, and when the push +# tries to update the branch that is currently checked out and the +# receive.denyCurrentBranch configuration variable is set to +# updateInstead. +# +# By default, such a push is refused if the working tree and the index +# of the remote repository has any difference from the currently +# checked out commit; when both the working tree and the index match +# the current commit, they are updated to match the newly pushed tip +# of the branch. This hook is to be used to override the default +# behaviour; however the code below reimplements the default behaviour +# as a starting point for convenient modification. +# +# The hook receives the commit with which the tip of the current +# branch is going to be updated: +commit=$1 + +# It can exit with a non-zero status to refuse the push (when it does +# so, it must not modify the index or the working tree). +die () { + echo >&2 "$*" + exit 1 +} + +# Or it can make any necessary changes to the working tree and to the +# index to bring them to the desired state when the tip of the current +# branch is updated to the new commit, and exit with a zero status. +# +# For example, the hook can simply run git read-tree -u -m HEAD "$1" +# in order to emulate git fetch that is run in the reverse direction +# with git push, as the two-tree form of git read-tree -u -m is +# essentially the same as git switch or git checkout that switches +# branches while keeping the local changes in the working tree that do +# not interfere with the difference between the branches. + +# The below is a more-or-less exact translation to shell of the C code +# for the default behaviour for git's push-to-checkout hook defined in +# the push_to_deploy() function in builtin/receive-pack.c. +# +# Note that the hook will be executed from the repository directory, +# not from the working tree, so if you want to perform operations on +# the working tree, you will have to adapt your code accordingly, e.g. +# by adding "cd .." or using relative paths. + +if ! git update-index -q --ignore-submodules --refresh +then + die "Up-to-date check failed" +fi + +if ! git diff-files --quiet --ignore-submodules -- +then + die "Working directory has unstaged changes" +fi + +# This is a rough translation of: +# +# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX +if git cat-file -e HEAD 2>/dev/null +then + head=HEAD +else + head=$(git hash-object -t tree --stdin &2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 +fi + +if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then + echo "usage: $0 " >&2 + exit 1 +fi + +# --- Config +allowunannotated=$(git config --type=bool hooks.allowunannotated) +allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) +denycreatebranch=$(git config --type=bool hooks.denycreatebranch) +allowdeletetag=$(git config --type=bool hooks.allowdeletetag) +allowmodifytag=$(git config --type=bool hooks.allowmodifytag) + +# check for no description +projectdesc=$(sed -e '1q' "$GIT_DIR/description") +case "$projectdesc" in +"Unnamed repository"* | "") + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; +esac + +# --- Check types +# if $newrev is 0000...0000, it's a commit to delete a ref. +zero=$(git hash-object --stdin &2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; + refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 + then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; + refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/remotes/*,commit) + # tracking branch + ;; + refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + *) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; +esac + +# --- Finished +exit 0 diff --git a/tests/resources/testrepo_256.git/index b/tests/resources/testrepo_256.git/index new file mode 100644 index 0000000000000000000000000000000000000000..838e73883bae7a33e15607de712e2771ac91b236 GIT binary patch literal 11148 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 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/info/exclude b/tests/resources/testrepo_256.git/info/exclude new file mode 100644 index 000000000..a5196d1be --- /dev/null +++ b/tests/resources/testrepo_256.git/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/tests/resources/testrepo_256.git/logs/HEAD b/tests/resources/testrepo_256.git/logs/HEAD new file mode 100644 index 000000000..59a4bb5f0 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/HEAD @@ -0,0 +1,7 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0700 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806603 -0900 commit: +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 Ben Straub 1335806604 -0900 checkout: moving from master to 5b5b025 +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806605 -0900 checkout: moving from 5b5b025 to master +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f 901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 Ben Straub 1335806608 -0900 checkout: moving from master to br2 +901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 Ben Straub 1335806617 -0900 commit: checking in +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806621 -0900 checkout: moving from br2 to master diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/br2 b/tests/resources/testrepo_256.git/logs/refs/heads/br2 new file mode 100644 index 000000000..e8ada8193 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/br2 @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 Ben Straub 1335806608 -0700 branch: Created from refs/remotes/origin/br2 +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 Ben Straub 1335806617 -0700 commit: checking in diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/master b/tests/resources/testrepo_256.git/logs/refs/heads/master new file mode 100644 index 000000000..4b4c53f42 --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0800 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806603 -0800 commit: checking in diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/not-good b/tests/resources/testrepo_256.git/logs/refs/heads/not-good new file mode 100644 index 000000000..6bac45bec --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/heads/not-good @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1336761944 -0700 branch: Created from master diff --git a/tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log b/tests/resources/testrepo_256.git/logs/refs/heads/with-empty-log new file mode 100644 index 000000000..e69de29bb diff --git a/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD b/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD new file mode 100644 index 000000000..c1c020cff --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000000000000000000000000000 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806563 -0700 clone: from /Users/ben/src/libgit2/tests/resources/testrepo.git diff --git a/tests/resources/testrepo_256.git/logs/refs/remotes/test/master b/tests/resources/testrepo_256.git/logs/refs/remotes/test/master new file mode 100644 index 000000000..42bdaa27f --- /dev/null +++ b/tests/resources/testrepo_256.git/logs/refs/remotes/test/master @@ -0,0 +1,2 @@ +0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Ben Straub 1335806565 -0800 update by push +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f 1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 Ben Straub 1335806688 -0800 update by push diff --git a/tests/resources/testrepo_256.git/object-idx b/tests/resources/testrepo_256.git/object-idx new file mode 100644 index 000000000..c4ce7c4bf --- /dev/null +++ b/tests/resources/testrepo_256.git/object-idx @@ -0,0 +1,1700 @@ +0007e4a07f4c922a647ac9930790e6640c61b8555d0e0195d164bce8685f2390 05bf6713e26fca9af0b116adf6fa1a0e4a3a957c +002bf814b089dd7941f9cdd449e8c3a52815e8f8f5fdc918c4ff3fe4a2a88119 3e590fb2221ea3c117b7347956843d24132ac22b +00404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b91e763008b10db366442469339f90a2b8400d0a +0052fc5cfde91bf84d96ea764b24ccd20ce9d98a354bf69a6bd89c2ad38f977b 00c5bdc46d8f91dda9f64086347d60c18d1a1f8f +0092a5b445971910ad22ef5636caf11f6926695fa8eeaf34a4fb7abecc4a0e44 404e1182dc52d4caf284d0f39567cde79649b651 +00b1f32aab597e7bff93f9790bf580b030f4ed71d620a7178b2d9a2bad5b1f86 27c3c27807e7fd3c053e0bffc6da68051f343ba2 +0113a79463a552823f5865aeaa641137ad8741ac85ef923014a6a7c0c36aa1a3 73630ef121eb0e4a601df784dff973b321813f02 +01177bbe7923049c27d557ed912d7440e2925bda5a37492744a83c1ff2fdda1f 5f10ae02d45a1f030cf0255ff813d62fcf7e5575 +0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 763d71aadf09a7951596c9746c024e7eece7c7af +01731a6f97a36dc0299d3bd87b16f0679d675dc8bfc484dfc1173e3dea5914de 5f340851194fa963878fa70e6ef4b19bd2c74ee2 +01a1e78e1078db69cb6197fbc564851bb5861e6938638169c9111bfd08b608b0 11d973c9507b5768f2c312ad9ffa35f0baae8793 +01d396efb693b1b691ada667e623864b802bf4b57bd4fade0fb6d75688a9b99b d5d4b8cd7faeb7749015896a303f1d5331638d00 +0210a4981f476c0d98929dded65b4dc0ff653f0876c45ff08a6e7a1d647a4b2a d39941396f81224f394f1d59c31f64e2d0424fab +0216b94271c2795357116d8f9ae45facd9bb1658c5a42ef38ea54e57833ffa3f bdf2334251d8e65a999b96fc99547ba99e2f0205 +0244a04d70a80f0e5baaefe7ac1cd73dcb00692f982e1e3af824252a5d48fb3d 182f2b39391ff4db4008554e97753fdba4e1b57e +024e2a82f18d1034c0954bc91c96af19c98029aaab3f6aa8fde5ff1f5e70afe6 f57c220bb0949ba4d6da1967bbbbc7544c18c0d0 +027d76e06b173a74af36c5d1a10761c830b59ed8dc03acc58d1ae008b176160e 1b24fa1fb836589fef658723c5a68cda9a2647dc +0285241dd82eda29ba38b91c04f6385fae1b1b88990f8d0c86a88b5e6401a495 7c25137751c32c3971a57cc66c564dfc321328e1 +028e02901e7de25b3a0079c438da76f03df181cba76d986d3445be0675af21c2 f206b37de925edb8e36dce24fddb125e493d2cc9 +02a6da582f284e708f78ab9360628740395d9003bae9cc9cd5dc47e042a95e58 39e01811cd58f4ea0f5f5612d24b3115ad0736f4 +02c3ca38a3cadcb769643ed692998c0f3984429600365a39e143e5984c33c871 a42df0a3df3e2524c532f9f75aea0ac69c3984c3 +02df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b235959d89084af8d3544fbdf675e47944f86524 +02dfdb9fccff7beaad58de3ae93694e3f957cefa10945d4652b3b1af4ecc1e41 a84d1309159aa125367376b01ec4c76847a4f514 +03063757ec40cebe0042c667ddb85bc4404925390abe9ce38fbf89761b9929e7 820e02ccef8c90470ec7f351464f9212f9dc0651 +033de70fa8afc174d134a3dfda7a8477b550dc12019904d418d9d0bb77d75c11 336ab27f4ead4627cc51ed162c31bc01f13b793e +03653094a4e4d102cb4ea4d29ca5d17dcd99a0d6997d0a6ea590b774333a4afa 03a9cba35dd9060f15a7309b438afaa246e80d5c +037bb440672e051dfb647627dd961209d4d5f65a3134aa561e9a22dea0c2ddff 6e9fb9dad8184cde865b1b062163dc209042f88d +039df023a072d4c4dedc8d69bdfd04955c9661ad0a6032d59417fae3d9a6e66f 93a16f146306fea6df405db1e6e065e52994ee5f +03c29c5b092a27c7d22553dabbf94cdd05ea9892de6a017bb7ebad8cd381a72e 8529bb1ac5647c96f1af4e933f34de2e9d8921fb +041ee569b4648c25a375895bf0e615b1e967164142dde5e3b74f42aebaa8b1db 15bffce9f7ce45f3b17d9357931667485a890455 +041f178780c21ca66c1a644e406bcc631e3374d3d3ff12963f27b7a2e4dcb98f f2ee83a040d7c1c26b85729558e7afc121d35651 +044fbdc5fa0794e3fe81c4cb6735792a7e2224ef108533d9e4d64dcc2f79f727 4738f4f3ea24fd89b4b4b27aa115eb6eaff9b397 +04504468bbc5da740dff1ee1bc21644ceac33a5a39e186624ac9c1700a005802 34a1dba52a7a0f2309c3bcca5ebd76dc8d2627c5 +046ec406f62cf062f45bcaa8881c901563595ad5e4e3eda3915979c8e8ac8786 c7417a02d56346deb435359fdba3de19c0be2f62 +048a56b75d20462e59f0b0c4f8c326013116a117654226fbd086eafc417b227b 894a57d31fdc8326a97814ad2403a45e7c8b6371 +04c49256444a1cca25ef7a6d0f6fb13db62c3a7d887c2b3bd0daf02b36665923 0e115c5be6bf252aa8cba76141eefb67f1541a06 +04cbb5dec4810b725cedad9ed47b8e070ebf7912e7f8a38b1524c7a5d18d6711 62ab0af99d2955901133fff37560bff1962e9b14 +050224b1d07966f578ce168d709148391b41eb6fd4b08e51fec8a549654a6780 c36f4cf1e38ec1bb9d9ad146ed572b89ecfc9f18 +05257051a1b3dc12041d32d8392ef288a18aa225b138ee92058a76f6453ffeed b6d7472f568134d9662dbe0753e692b7d57ed993 +052e483d293dd8832a959201ae52fbe0a3578a53dc964260c1ccd00563109d05 e8b17444a9abd2c9be360b44a8f8e13a4a2fdf27 +053bb083785b3e6287242a1e9b7cdebe356a25574b5f063538bfcf01d646f0d8 f15336fafccff5f3a05b4f4d1527254f25a364ef +0541301a56755c364219db68258da2e70e9146e9cad185e78b188d560dfbfc38 45504b7b9013d55e193001c8336f3db0ec2a81ed +058ec10e754833d209791fc619b8651f9f8738eceb4af6c9c4e096656b4b5d0c 639753339cadc1e57823094276afd3b57bdd6b62 +05a40f056205025b75b15337629dd90b2abe57a2622ca7968db2ffd4fa1198a7 77c0fe987fc4a3c24843c77615c3b6d2f53e27ab +05a580d164ba0fb859466759e0db1d63795eee186a48ad7b6684337933ed16b7 448a7a7cf218a5988f12274945613e86e1c2de11 +05f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 e7b4ad382349ff96dd8199000580b9b1e2042eb0 +060c18716f5e2d8c74a30960f002096e43a4a8b0344e3df4f81222d0b7d73b89 7322d43c8aecf06b61944b8fd63d60758680a957 +061079b6d522c910cfe03f6549a63ab4ab43e212aaaf7dce90bdecd4c4f616d5 4b8e8b32c1ea1bee8c8c01795e46aa97006bb065 +06240c7992e7306c80b1d058777029034fc2a9028931dd93c5611bd56332b99a d5f668c547ff80ee9c5ec24613a2e552cb531c59 +062835d273525fdde70fef08a703cdff6fba048a2e1ef3e49a4a6f60e7e5c7e4 3e00d3bc4d8a36c974bbe91608da3b6b1af69caa +063517f949bd44147862a7eb7210fc0baccdf6c5c02c18c51459c7f317d803ad 2e2a9ece460a44d8f30f3df9af1e3686a8e609ec +0636b4292bfdd7274a977cb6f8b2ded8f315ea1bcd8dbedfca37964c2ed3d085 236e7579fed7763be77209efb8708960982f3cb3 +0642ed9f6735aa25854c90e266798a4843922fe3736a04252809e824bd4093d2 5db59540265ec48b82f604cd251907ca5d79b6fe +06665948a581e547ac1dc883b35bab54682fc311f7a87d5563a76501ecba55fc 4f0adcd0e61eabe06fe32be66b16559537124b7a +0676bc9e224b7a050b3e88cf7dd8f7fb148f521594a6d4132f0400bba6b1da83 8e9d2f904854c0dab03de84dcef103c1904b2115 +0709e20677dfeeb21242f9f7fa277ec464fbbfb56d303f8006c7e60c8e2be458 b3a2f90e54bcb32a88d13539e5672993c5037638 +0722571dc44f703576daf0dc43370557e6e9d83784b9454c98a7246ea3e0ab91 215da649e1c68079fb03f4f9bc0f196cca9855c8 +07314e5bfe0b98c1e061219664284ea9567e1d739530b3be8e3a6ef9527d59b9 9d3c39dfd8210faa558b0cc6fb427b680db343e7 +074acdefc8d17e7337df33b74c1ec5349ef0a0b18a7ec5fed41a2cf420db4f5e d8310141b69fa36657a620a045acad4e4ce0920c +074e9049747d5816aa03be67451eb42c425d1e328730b4d999dee78c4d2579f5 caa7d9e0c8f8671cf8b8c9c16eb18d31ca4802d8 +07571960f3f64bbb4d31f24f79abe05daae0498f6b4b77cca3d8e8ceccbd75d3 ad7cf03cce61aba463b9a687e388260395c8e727 +075e288bb4b170c21e5a569c3cafec80736aead134829acee0f9d4ba5b966a24 e9f5e87781e88aa3afa7679783c204604479f9e9 +076202d7d8fb1d193628801f76208f3a4967fa031a7f94d9236a0fbbe6f022f5 221c73c758cdfd3e7f7dc45b10576d1ced8232b5 +0763eb50fe80aa21eda853b7da406425b172b1d0ec7bdb41369a15868fddfb6f 02e741c6fca96b6d2bb89d064c3d1e31625d474c +076800113a06dabe75d578f2ce6018fc23027a83dc74cfd66f69f3c50f037ba0 270eb8c6bfbcece0f3abdf20f16f5a2c0b0e65e3 +078baf54914fab56842798c90fec863f15f67a22041e8aa54a88c43f059da050 3184a3abdfea231992254929ff4e275898e5bbf6 +07c31b4be5f3ec8f82c7ad6c91cbdf07ae876bb73041903d64fe8bac64bbcb6e 4ea481c61c59ab55169b7cbaae536ad50b49d6f0 +07dcde657a4d8046d02962b4fd67ee5b6ac27f712de66ae22c11d14406ecf092 b39843f3e42c8e062a29b2a64e3c3ce6a16eb72f +08198b33785f1eaf950aaa9ade1961e1513461f7f799905a6a625946ebf2db8e 1f9a9b4edab6da73b1625fc99e57fd84b88feaf7 +0838ea9dbbfb9167ea97d3b395b06abce5c951386d5549d87b3c4fe1ea8cbfd2 52261e14080afcd9cb0b1b17dc4146f2b6b252bc +083c2b8b445640d171e7aa667b0b32007006f786711032ebb82931cca69cc15b fd8430bc864cfcd5f10e5590f8a447e01b942bfe +083cf84e4ec87e8df6bb8cf4b5e95a5bf0e6b97b892fb99286d652362f0f1a8e 2e5faa78b12048d2818bf37986516cd287219f9b +083dc854acb0f53c854ca89defefdd7c9bc76bd6158a461045057c8febdee51d 2c4b7707f7e1d591ec1765ab7057a03283841c3e +08896c87dca842ffa2e7f9ca1941fc1b231b4f0cf966c992251fffc01be4eb0c ee5f4b6e2c16c9cf2510fd7ea60afb830a3e89b2 +08af1ef3969b835c4058d3c19fd6f30d0dca883b9553061823f016db50b935be f4153cc66a588da14bfb5e0ce59dcd638e6cad2d +092184eacb4296d03cd379da1e30b23163a3174e74f5f072b71dad644565d5bd e7bed373b521d9d5e20c3f7a2372a7eae76ae66a +09ca781675e86449d0910da772dfad9c80525b52452ea837a9820c3bc349296f fb799dfe77c7a1c9e2806c0021d659b5588d9105 +09f22926cfddb415baa1a22193d765facfea02edfb140702fae90714dcd402c2 621dbe6381d0b5239b6ca2f206fee56877326d5c +0a13ff7efebb553b2dc091008c6b27ae8fd8da265a0fc672ee0349533574a1d6 892bb2941b4c993ee188ba1d2da6c305dd5f6ff4 +0a280fa035c75607e5399cebe0e2e4ab44de35bd4d5c46a1accb47c8ea2bbee4 417f0abc9b41f01520df863567b25efd03bd281c +0a45b25fa6ba0d67638d8230be426a7a61baf23ea734ceea38312a380dd42181 a78bbeca7f7efad6ff1652d4ab03d4fbf8bb4c48 +0a58869d818eb06ab4b6601c466755db3a7e0d310e87f9f5f340f4ff8f3d84af 55eee3fca2f24bdaef26ea42ce12b98682b8988e +0a8400e1a7dfc68b38c9e82bb4d64f94a20f75ba0f026eb14d29ec978f66dd3a 41fb16c71644d9acab037f4a43d23627545d6d86 +0a85ae1fd17b2a87e83699ba3dac6e0ebb2efd62948ea70dcc127a250323b066 6dc05568057b37706c8453b3e24645a351fef6a3 +0a8c0add81b065b97451f7b47a9935f0e240251c5f90a89ced885cb7d4efc2ba b0a3077f9ef6e093f8d9869bdb0c07095bd722cb +0abaf90248f239f967d2361480e8111858721d240de6e928a9537af9a495062b b6d031157980136043dfbca0e49514a19c973759 +0ad45dbb04ca242774c42f4d7283094c9d0018db25224ec4e2b1512bd3e21e5a 45fb9738926af78da7280cb84ea022e8f7da98c9 +0aea420f9ece0be17a656910e5a64f71a591f2bb4a8938090680925a262fb511 0bf364b355f1dff3c70116f8629774848dadb9db +0aefd477d9e5b3f8d708a3cf6d78be6b670dfa2e2ec41244634f3b8f115d8e04 775e4b4c1296e9e3104f2a36ca9cf9356a130959 +0af326907c9f9a1c91cdfcba6e241582f97ade4535b16a1863b03938ca983104 29a210a471a1964a68f7f1f15214c626c58c1701 +0b1a932c7db41cb113d42e06acf29eddd00aaae9e39398328d475754930c6cb8 343a4b52f37094d193a27fde5ff20825d6d1e7c3 +0b2613505624d7fb949258282f13add0019ba5521f3075ad0f61bc1306b6d828 faa612641fdc2590a969e9a8600af696be701f07 +0b41ced8fc49173b868c15cba070c0167cc83eaf7c0bc62a19e2081d1e7f2676 2876a4c21cb5848079e2f2700312e54d4988c76f +0b6b4c4b598c420ebc1b9e404f53bbac59c8992100a92fb557d679a65e6c7bd5 ee2eb6fafc239de8d88016a1579314908b643b87 +0b99d2b73b57e4d477d096a82661320656f2e61f1d6811f569abb99e2d321b5d 3864bcd2aa1fe77365e8310662c037309d4db56c +0bb1a5866d49c4f22b173586a2d0f2a3d6a91d8ed4d8f6fc43a624df4afe00d3 1b9191dd8a427addca8309a59decc90267082bae +0bb5c743db0d4ef0b30982921e78fe42863d48ea34a6a917bf740ac2d677f281 9689311c952655dd9e315aaef81ea7bfc60d7c7a +0bd7502a0ec038d7740979ad9c9d2198f61b51bcf75b20259aa56e845c62c884 13edd1b7d5996a6b1ac38ca113f6fd751bf77827 +0bf8e96a28828be201f392a2f8d511d4b0d88296db716d64bd9e8268a5cf912a f019bd17a1769103dd82b885d7b46bb9a30bdc29 +0c0a6e5b0322e1f51e3a53c3e302901e9f6acfd0e3f9cf227bd02e61ddefd401 cd2c3cc64b9c003e5049d8a3efe4fed7154e6e3d +0c4f26749b1dbfbf4487590dea5b6bb49564712cb3f8343434092fd9b2ef0a0f 5ac6648ec382ec2f2c9ef81e6ded0f2fe5819a5c +0c55511a79e278b18657bfc60a0893d002d266c05809f54aa49337a0973a1eb9 6013ffa66ef5d856b2c4c72c44b1a63a7ccc2b57 +0c889bfb5e530a62c89b8c18ba11f4bf3417582a28c70b51f075ae74ab1c9a6c 5152c60f1d88042a52d66344b1d628d2465fef6c +0cffbec3386e267c6d32c541b5eb3e0492851a5b35b05a506dc60b8de0410b46 7828fb1437298bbf3f31da65581775665eece9cd +0d15b51f164a1237b5a6ea2f35f32d3f953c4476c1ca7edc91890cd5fb5d8541 18eb2b8adddc7eb7e2a0165e8d759ec5172a65a8 +0d737e3eab91d43f8080513e45fa2d708b3626020ff4b6900b236a613af8cb6e 34ff3378eac2b37e5220195e235a25a21f9b7e25 +0d8b5fe52e725773014a0487616540efea381d2af971ab5a18ab25d33ead1390 9aa923b26f49d08404fd272e0688f57c899d9116 +0da6d514fdcd1a5248f1ae2343991a7b08ee5da3169da9326ade767fe50bf166 74c7fe4f3a657d606a4a004c87336749079c0edf +0def2b73f560d08d26ce006d956af37c429277d3b492839521d00403060fc189 50d97878f49fd4c950a7a494b8dafb0d4797b57c +0e1ee44bdd5aeffc3a6601c83744e64a421a38d1c9355cd5aa20a1dd7c55d849 73473718290fe068243e8596fe649f200e8a6f34 +0e265ece40fee110c5a6cd29be1534c268f16e4f3c488bcfb9f3c8d1f46a4791 711223894375fe1186ac5bfffdc48fb1fa1e65cc +0e278cfd338b1dcc4f15bebb53ea527e756337a337e46d29806ed28c23f5469c f5124bfd46444f572c5faef3d45b084635c106a0 +0e31ba4e455789640544ac02d4e478fcd75d39de130241e0d2bc80db11c7b7f2 8722a77ec384aa0bc87b8f8f6c1c7ab6aeffae83 +0e3e687c74a6be88d4c09233ebe1d1a75748e349f7013284742e200c56821d9a 58f7931837dc08b3f94dce8ffe743afa40b15f0f +0e4970dd94378fe30b6519edf25dcff7679e395072715c12e6f365b74ef94415 624320d5f878cb1603c31bfd8cf1427fb6474443 +0e49790ea8b918a427928eab3e17f8925efc10e2c1a8c5bdef4c0eb20cac0c77 0e40ca2e7c706ac2f46af7f4f2d4bccb90bfbb5f +0e51009a15c1599ba55888c464d5d806694702f0593bd59895e4a134026bd34b 9e41833ef25a52288a46441ed9ad03dccd0b16c0 +0e6a1aaa2118384e5ceb8af69725827ff4bd942200a9b831522dddfb7aac8287 763dd65d1e7ca14658649d7c4d1cc1e4bfd2c671 +0e85ff7bdd5c6ef0a1a449461d1d01b6a0bcd3393a994bc5113915d173810071 e17a3f5673e0dc4d9ade34a0a276e6c202506fdf +0ea35e446e65bc1894a303aaff5ed807151bdbbdc8ab257510abab4e83fbf13b ab42d1514cd6b1007d794885dbcc0e7918e91b1f +0ec37a6fc3216ad07f16cba63ab57f80dea7e4091484cb25e6d677abca268fb0 9e210cb8bb8d3ad9204d90a584098d43c456a5e8 +0ee0fc56010269854bdcbd4a1a55675b2fc29c4410217004dbf77d3ec948954a b5cadb77fd216aee5dc133012142de6f78d4d47f +0ef8005c1111d4e19e9636d02032c8c3c295ba6f94598e4e782eb28cff273062 408509eef776dff28a36b63e8785ff04f7cf9846 +0ef9ad163c0b4599adf0444b293ad267012e784ca37dca8d8c286fa36914001e 3a6b70664b4c5bc0ea2e6d3fa8fb3b3b54d724dc +0f89c2e306e636e3084aa0bfe57938fbcd22981e809b7fc031ff90250befb83b 226eca421e206b16826b86f9aa9706aa31680240 +0f8caf733b3a1530869d8d6faf6d4069acec05cebdc33f15a8effbf0c7daf370 e92aec82dae6f9fc5d96b0ca7ce39d750905d7db +0fc8f0a12ec6889419fd677c9830b2d3feec2e9abf89415147cf0b3c6d444a35 182859f51a5cdd6ae9a1f75e21eb8d3f95d0a833 +1056c834175ba8749080270f4772ed2aad4ac1b74896a7cd36a75fa8a1aa53af 628c97ce7d9539e1009702b53fc7aab98c7f7759 +10b531c577e3e3fac1dee215ea33ea21202309a23b93352e1a9f09d6e9f45f4b 169d698699b441e9912283936a81aaab8e59c6ec +10d12b721c027f4041d0a52d5c02da1cadaa1ae0d05051421a36b861c4df210b c960d6a3f97ebd360dc3c9ea00fdb3cd5dc56224 +112e60f7f4409f6427a2bc302108becea27da72e31f92ee3476c31347cda4cb0 d22990a266f309c6eca013259c35ce567a0dfe08 +117e89c749a48a0c10b47e9433f26efd38192395676086af83ea2d48306b9f9f b4164f93a830a383b69daec35b6902f0cfe7ac21 +11bd4567822919bcbbf44a1323a1af5a0fcf9e2c6e3d2ad1329990eb1c0e9f5d 83de31463c02d36138f1d76cc22c18613920cd3b +11d0463a82345c2512bd704dd00211aefb7d5b8590ca92809122fd09486a9f06 d0a0d63086fae3b0682af7261df21f7d0f7f066d +11d187fe3c4fde36184f7e171e9b6afd066563b4ed568d9e1e3195b8488be47e 7f8a1d79534d90ed868ba664343b058258ddc64d +11f2111f69ec85dbbb408d68349c750a9ed94722b094e971f595f8aca5028713 0b19f4634685fdf3c2e58564038e614b8a8a563c +11f58a21e063f88f8aca15a05a6bb5148056acdc619be09214bba78819727a92 58840c6f7e9973b3700eae294e6f219c34cc6962 +12240f46f98af843abb3e12053abd997a1a5cf7ca50ec460775b6dfec9594346 2c9eb23012b2c0effdf247a9dfdeda4dcc6ad8b5 +122a2103f404b68ff8cce6c6ae82effa1026b8a254212401bf5473d27d70efba e97179b6de293c8f288957dc556239a44fa52e3e +1258e0cba7f787b1c74e00872bcf43799e5a7c77202685dc0ba60adc20da977b b2dea1ed674386234946b2604df68d71b677d2c1 +127437808b4e14417e5654a8e00dac615d334a14747d78d2ba1bd0df426ddc18 60711175510355240283174b84d16ee85fd599ec +12a834fdb798b91600e94c6851fc231cfd20f3eb65dcd736f39fecf96bff2788 edc438eedf6854c51e1a0d7954a6849046f5a4f6 +12e4e4e3649c0817fd80bf805c8daf890b40fe6788fd479db758575278bb58a3 91e5038d62abc64e8be483f3f764e51b0496de27 +12e8b48d89fb071c73fb0736f784c6ef0fcc2d4178a1fe17ed6d7a8950e6943b 01316e2444ef01a3a2939d6d891b1c7ee49bd05d +1331f4c99429b5934be1c4186c592069ee9167e73e65807cf8004ba54a151fc1 e740db6f334253940722dccd42ee45c96ee4f56f +137343a187f9ed56ddc750ccbdc5f284c1240ca1061854f609b4893cfc0ee035 b24cf42e6753bfe5763fdd7639f9cd8b629907e1 +13c8c9dae9fa63b1ec48b8abb12312fc8df61b9414678f504fa68164a48eef28 31438e245492d85fd6da4d1406eba0fbde8332a4 +13e9b8e6cd38ad58df3b3d9dd3480c06e69ea21f02639404c44c57f376ff2ec9 cb8e90b049ec87e0a999952544839c3c17f88e37 +1402d1979a18fa32944a3e584bc2bf63f08fd50fd16b228690b7c8614923b603 62860787aba2b59b1dd0bb7b9a810fbf3428cf75 +14386136c01f7aa705d82984066e49b9a3380d4f7a7f42dd5cc51511314e9a11 a43ff639453d9a5e374cd655bfb562d2d87b9edd +14747f3fe457467be5310c526d23808fcc18f5bf29feca812a3b3c74dba53a39 77c39760447694c5e9f5c7d09acbc788560a322d +1483e39b34bf45eeceada3f43bd76b8f1d8af079128291ee1f0ff9868fff8539 483b17569d2655bd9945ceac8e95c4279b2f2b2a +14a40b61fbea11fffdac7e51616ec7a7264e88a16a9021b4e252d443794d50d2 a27fb9c96feb433fb28a2713a863a7356d45eed7 +14ab853cff3d477dc79386905229f0854da0bd832125d6e8c3f3186073ec0709 b6d1b7d59f42493a4aa5440ce24070bbc4044f88 +14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f 4a23e2e65ad4e31c4c9db7dc746650bfad082679 +15011ec9c79d290af2e08c865de53631aab299a27fc2a681903b3e3efab7dd47 b5cc24e623d5257f37da86627b8b314609945cde +1503ed3428050930a44def1fb250fbee95bb021a61f3ebe831502871c7df0035 f78cfc187cfead79cbeafb6e0c30f882a9d7c14f +15041151380e43cd57db1e6b758b00a2ec32782a3004e2b1ededc5e8bbd2e815 09fbd28ab7ae43f75acdf7c8adc6d148b8e78d57 +151c7527acc5b731199a03a932ae374331e16e5ae29256e98cb652f37669889b 91d973263a55708fa8255867b3202d81ef9c2868 +153c7d90e1734b2c9d1b32035aede6299a2a2eaeec425fabcd86706c8afc6194 faf2dae9a5d206471233bfa8698ecbdfb24785d1 +158217c424b47fba461c300c9f99cc27b50f7122c6156d4264c648197e634fd6 c14aa17cb87c64a3cc0f21e343389bcba1992d32 +15a4a79b6ab927befa6798c2028d37fa6cb4f6fe0bf80fdce6444a2fd9e67eca c72d81b5de8042aaefed06ca1abc1a248bfd0a4b +15bef585bbfec8410833ebdcb1760b7013d1dc3e4a7085902f199ed303f26098 89217d8f1a70da2916d611c989e6b046cdb94fca +15f128540ddf555e902e837a9e4bc39d752d70af7de1c91b9b0048c1bdf4ba31 f70dcd0924f1d58e9b68ec47fae83d29696865d7 +15f8faf9eb65aa6ddc66cd5a1519d7fd4ac08cde54d6b25e6fe1698c55661335 0c51be2c8e9c40f947c9527b1c633c78c3d56e0b +160a14259c471b4d0ef1594494f33126d5763d958ae31bb14e95818399f6e3ee 01e0d82509eadc367a67209ac1150e299447cb25 +1632e799dac6927cdf520ba3cba8987a1258382dedacf72dd5b3316af2fd619f ad2fd2eb9ab0a392524bc5d4a90888d550bcbc0d +165ec90aa4190bbe12ee415b294fd6d204c64afcf1ca64dd815782872b24ea26 904c0ac12b23548de524adae712241b423d765a3 +167fd44243abde82c97106ac315e0f026b447dcf1016918ee42c0777533e6c0e e7cd3468b748fba2eab5162991ff781e2ca8507b +169a47e7a7d688f8e6ee34ba57c07f3d1654f0886d7e0be582ec76cb445af1d3 d1aa69929be363f0798f1ff226078c9912415f5f +16e15f2497ec3aca6b94a96dd1ae3e2c8c5a351112345e16c1013ddb23fe9131 89d3150640c0ed5b386bc8113ac8999b20371ece +175515c1c0df4fd74f9f4683321b84cedcac3419563a268562f08560ad7684ad 3b8ab0b93539049b0f7c4a09f5dad48a1d89cd49 +1784913c0c472812c39dd12870f8fb69346327bda8383d7c2ef22d611c808513 ea9fa2b55f597931edb375c234b42833321e6ebf +179496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 3259a6bd5b57fb9c1281bb7ed3167b50f224cb54 +17c8bb815beb9afed2efb9fad7e2fff9ad127e2bbf742e7688d70ced51875c11 4575d8b63290baafbdc8345a297945514542f2e8 +181a0d8c3fae35ec8f21046d043457cfb07975ef6ee20b3b2a2b75ef47e6b54f 017867366494259fa88e71955be05758b17f2568 +185248d640acd5ef59cd18b373ebeebe0c8f5d31e8d0da8a39b69509b82a8b38 3cc1e1683dfe9fa759c81ee61b2871cf95f0a3b8 +188d0f5e289ebe28d3eb0027212ea0b1af1c84ebb0229c452922d277ad4f6b41 086ab3e1892c5375fccb647a4b1e2d9ed55ab750 +18c2e619f1850cba3b69767e9433d37b9eba4616521994568a09e6620fdc32c5 46c7d0de2393b0064ff2b909a34944f30a80d8c3 +18ca8ae1ea1ab24474fefe881b7ad27805bd8942051fa9421c277b0ea0909361 069a41c3acd6dfeba2d5ebd1ce0e568d5ce3ad51 +18cc02db4956ff4c1ac8b49430ac9aa889482ebdf985e8f218415038466e870f 83fc82fc80ee42dc76405745ac74a80f7b7a9fd0 +18d28fe4d7da8143a66562a085a1082caf7abdc6ee0dc13c48a509f82ef9a6b2 72afab8fbae47da683ed24f4a3b5deb01c73ea9e +18de7aa78fb2acafc30a3bfb0b5620543d2d9c21b8474f0d02ea94ac16b3e414 c1f22c54fb7ae97543f8fe6c6ceff95734f4f9c3 +18de852cc5d52a03ac90027225dd12cad93079ca8e1a2dfb11214ee8dc06deea b447fb5a08337aa08134b854f8d65369f03c37c2 +18f2403ff16f42833737b7746497f5f79c014e1cb33bd639c47d7869cb07873b 480cc70e318d8a80657f36fb55967477050cf3ec +190a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e d71aab4f9b04b45ce09bcaa636a9be6231474759 +191782022d7767a9a15579163f106741358f2503fec2f9c4c093a6718c0c764e e5f6ef80021c1a1ce27300c4de4bc720a08ccfe1 +191cea84239bce688afb3e171e9e4b3aaae9d419515dd5629b3c01902210334b 2a7e671b12478a4246a11e8f3db61ac76f241e5e +19762806906133d4265885d96213490c2b04f17560b8d724f91770913531488e 422ef9df86d2b3647e8d9a0525318b1d33dd9f34 +19ac68c5ed3b0a7a8b9f5a4a7098d002d70e0578f8735105ff622805287dc356 8e8169ce53213d649d52304e3a8f98ea04c35801 +19c0e0233f0ce56698402b2e9bc0c77a02e5089c3e28d03f55c9a3bcd6c1df57 76a8c44727406a76d251102bdee607871887a119 +19cd37eadbdbee580b4e2d650374b1e2517600ef4f45666547f9030a1de25a40 a23bec23d8075a05cd04df2f52fb2fddc8ab4185 +19e5ca97ae44d0f46334d1bbed31bcecc2b753ab4de4413e03c3020a2ca0e68e 8157f9e57bd9de5ab95b89fb9c7192a5668322f4 +19fb1c78b11f0f8bda658d6fa6cc63c0b573c0f6760ee5a9c2df6ce2cde00c5c 09fe9364461cf60dd1c46b0e9545b1e47bb1a297 +1a002e34aa1589da6dec7e55014927ebbfb007d33aa6d93dc1aea53a9711c061 e9c9018f4b898a2be9aa0d053153cb7d8c8af22c +1a08ad814e0d9ee5f719a39c4efe32a55b5fa1bcfc7fde7cb527b30e2fdcf33a 1b30c5d6f15d06aaf5e4edc55d33d440890416fc +1a174438f39a3ef0bb9d11bc1532ba677dfd530d2c71429eff281102f8128793 3517bc697600fa61730369f35cd91da86e12d595 +1a372ad827add2ebf07d3508c8636f891bf9fa15d173b7299614d543fab4208f efa3c49e538c7d0724cbd9c32b24bbcde100b3cb +1a6a20523216002f961c5b6b0e2b9f93fd002adee3fb48c0b038c4219dd46b35 5e78a5bc12d1dcd94751e36dff18badcfd9dc89d +1aa24b7ebd910f39a676f2ccab8e9a79f14842c20b55ed18e3dc297bdbaca279 70957110ce446c4e250f865760fb3da513cdcc92 +1ab4fa663d22416f45cb1a007d767a58d0abf5255bf86f888393dae637b37c3b d0a44bd6ed0be21b725a96c0891bbc79bc1a540c +1afe3af49295268534bff09062da89d993de8bf539031ae5b5deed8c74e2ed76 b371c056bb696430f0dfcef0d5e2bf62944ff323 +1b01b7b52d7ef909782114be3168d4c11d9125138c36dbec219de41bcc729c1b 7f7103b840176225a27d40ff95c541ecaf74bb59 +1b0218569c4ddcbca6d3c5793c5e822ec57ae0a1132ba51edb9131b68b361946 a916c9b256fe6e1c75540972d2c6ec07acd46384 +1b1b914f2ebd1179c06130fee875bbdb44fba22bcd879e460c8cd295854120c8 a0571e5b921af9cc8aeaf14688ee22fe9146371f +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 be3563ae3f795b2b4353bcce3a527ad0a4f7f644 +1b8fc08818cc6f44cc340576ad2f114f2b15e4f8bc4d306e86e97f65e2043eaa bd1a70b317032b45e10b9d24515905c86baa071a +1bd6ab383a4cbd2611367ec21c4742326fbeead3ff912f194af0f853e7b63304 004393eb8ee7f51fc57f25ebfee55193d74b3b07 +1c24b0165ded9e7bd0c8848c667f0b08a8212496303aeddf741d5e0e4da3f81a ac04bdf6e0ee6bb4286343bc70d745146eb1e506 +1c34ba81c57a802a66d3026e14cce495dfd8263ba7a98233c4927a74e441aa3f 08d5d00056a7237bf6c60f85a6e72b7549cf9133 +1c4cfeabeb57c496034724e4649ab5acbff04788b6dbef87c50167e16e91b571 5a408036aa992bffa67a0000ddd163e45be5f457 +1c7bbd4852fde2f3dbb2990d329a20e76ddb3b2b570416e4c6ba5633972f67eb bbd29af5b49251be2a6498bd84b488bb4304ae96 +1cfb8ae71e9e576d1b16b7bd1a62156d0641c6e51f5d76877be6de4f26410623 b1bb1d888f0c5e19278536d49fa77db035fac7ae +1d2005951bd5058f1b001eeac119a95f15ae052239a17e43180fe02624d1ee54 a77eac7c388ce4cc9da95c0c66f0be2416eb1197 +1d3847d94a4153fa5b4171642f366908c7613ae239f8135f47a38baf47812292 2cf16038b9c815d6c2be936c90f76049483af23f +1d4b030078160a5498398766e70bf11699359798f01d47bed25d1883eed4c139 c0972c6411e01048c50c98361c50ab1969ef8bcd +1d7bd64ed18b5ce0ef15a15ca1294e92e403b58fdc621382e4dd8125b736a203 ac8abfa28ae1dcb1ff4bcc297a7269ad64e8f486 +1dacd6409a61346885f7998a7b2abc74bd00a588d100800217a3732b55d7e027 1763ca88b7bda3bb7e98f1dca8d49bb9dfa3373b +1dd44fb999c3043ff69a7d846378969eb6b425971eaa49d14628fdb85ce58345 c23841c833ab35d82b32553d0659e815859e6c01 +1de74dd7ee94c061dfcf5906456ad25ee317925d6f6545ed7e5c8deb4dc2ef1e 7c106af8cc957a256d2a9dccecbe6b974a49a9c9 +1df5ac46362cb6d1e92e3b62ab4833c8b9db62bf69faec2456b88eee8d1922e8 14599df1093c4dd512ad3d54892c03102f7aeaac +1e0acf5db1f4a90ada03fc3df61f0196d3ea09f3c592de0a83f2cc6d5fbb15a2 9bffded46b22351f3c12eb5c020ae005e57cbc90 +1e0ce38d00e8f3e613febc0f8b275e0fd7fbef8af293fd62698be46dfbbc937d 8ec696a4734f16479d091bc70574d23dd9fe7443 +1e82caea1fba091c1795671232b6de19e3c9b18015bb66a158ad4728bfc8e0b1 8b2e33413c0e43bda8a98c5ef090561605a366ab +1e8a2396a612e14b5a4a7f23ab5cfc15df6abbcc5ab6ff9c89a3788ab450f0dd 3cc606359d5ac5c869901d89d8f25cac348f4c98 +1e9c076a9357a539b2126c275c8774c961ab8bda2dd6cd37750ca969dac15d6b 2944c0cded94117886bb85e4e41f7d4a3a553245 +1eaafe5b4dff4769bcb95b0adc254d77016aa32c1acf1d765cf44fb85c5c8b4b e2ec61507666a29ef12e60eed443146f8431edad +1eb53bfa2e681bf9a76be9dd3a9c2a5deff28be13d29b2f633f74f9281eab61b ccbb507cc3bb0c961c35d08c7a1d18009ac3bf64 +1ebb7c1f5a6a2f0151c4bbec3788d0d065bae1f0bcd152c9a3ee35b41e1db2b6 efaa4277c709be26d6d475927569d592db39b4dc +1ed3f54cc02a9ca7528af4986af6870319d1f9ea1d2a2ac59c45cc75277c34f8 575cdc563801dcbef0ff667322c8d00176771516 +1ef82afd4f727427bf8d10690824f403713558c930ab46a90c2572e214bf7aff a9d70a87634c0932d8c03976c80467cc5de7522b +1f6ea2cab887a2ff4bb1557a36dd6bac9931ef1f36794ddd22b4b7b7276051fb bff8618112330763327cfa6ce6e914db84f51ddf +1f7bf17705d025c6ec01f2c3e48ac73674b061f4d33704527b12220d34fbb32f 81657de62397e72bf47229c7a0a27f0325ddb8ff +1f8268dfb6d72ca7bb47bef89869a745d98b950af1dd62d716b70edf33850f33 c5e5c7d94109f5b26ebb69ffceb81f0530fde633 +1f9efce84e985329c26351dbdc81516bcdf02d1e5d64a92fe097b62f9fda8228 8601554dda0b46a69fda76189c126fef0aaf1ba2 +1ffe1f5d30a25e6517f439e1a05b59bca7ca16fa26870557901218e2b3cdbd7a 6b0b66190924ec57928b827412a75ca7643ecc97 +200f1e71b8c5655069f997534192616f9a3344ea45caf96b889cace34b547572 2ed634540823fb7131f54c5f1179c8ff1c59dbbf +204b6601aea846e40b93e2859b47760350d0d29d2e100def2f89a4d9aeee4e00 58653f4e36c26ebc8e3622e8f3922773082cb328 +206acf23f3313f369c63f14e9d85276e95b0dbaa3cf271e9ab13f6b03b70979e 9cb1d49a7a94f9cb757f414ae46186f1bb36b839 +20ce0489de3716bd85f6b5787f155d53bfc81ba930bf4329ed57dbe4bd99a367 818d98c0665384ae6ef6f7bb0f8d4b0c34acf9b5 +20d7a7a6fda600c0c703114b07d8469a9d188dbdbf1fb3494ac72b2af899905c 09e1e12190d1de05ea714c98cedc81777eb40545 +211597b7b8ae016a314953731f661ce2fb4061ca2f867668fb6114f1b2693b3e 46b55d1d63bd191a9f364400bc1c9112349c5ee9 +21492c6dbc50134219f63a081f52e3aa674d90070674a43332eccd2f4fde17eb 97603e2d1760651b6749067ce3d980ccab9c715f +214e2d61bdf436636b18c56a7ff55107de6315c85e7d60ab793607b173413a17 ae692bf0e91255fb9ad8393edfb73c6065eb82e8 +21824283eef83846585f59963be963b547ec08faedd27f5a994ef76281d0d2d9 f5a98ad911c9ffe375ce43fe23c1a3e4ef47e999 +21ac834dcd64c8c3759d851ed4ebd3a9121338d2a77c5ee0853046cf13f7bd4a 19c6a202cea3421fb72f7e4c4eb90fa35c391554 +21c3050b5f1069492acf40767ef180b24b7949a9928d7bf52e4278b53b64467e 4430a3812186c60d7a3cc7048f97a4e05f3048be +21c709ef5ac66209b70aef877fd0c8bd77701fde29e7e6343eaae9cfea3ddc7f 7ce8cf840e9a4d86680c0c13788fb744636658f8 +21d1e21f58b5003ebc6c47526f1efc9834c4fd77df0b7c201bb0809c881d5ed9 b290b470aa40a42fc5b24a408ab9250443aed5da +21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 7b4384978d2493e851f9cca7858815fac9b10980 +2252e803f7d4a9c197725e54f40d4d10272edaa05570832be4ff849ae4431fbc c6736542ff91f0d0c6b6a8ecf08eccd70f202cbb +22a3c8f57f9465c979a96ae07e60850d2b19bda93021c982fb9dcef491bd9aa2 c863948af21d4a58a4daaf359f38881263b3568f +22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570 dfae6ed8f6dd8acc3b40a31811ea316239223559 +22ba8f17bfeeb46d141280d030a87674e2be73e2360c6b60f0d925778a894cff 791826cd86946d8aed19ccdf7d7530da2023585d +22c61fc7b3feb0f7cb851cfc5fb6a3d84f11a63a4a32d9f06bb6ac0a332f4888 a4af2dd790a63f6312e6916dd0881bfee2cb3201 +22da3f3c129409fa9d299e05428fec54d0a4e49e69400d6808d9caf21d3e7253 880aa99fe67ce18436b9d253ca15565e22423f15 +22ea84a1b29b0fcc3889c026a418eaf785cd2f87702b023045e60c76021203b5 d74679498086d0fc2293dceb59155c696b11b86c +23380226b60b663254cf2334626a2918975dbe0029ded408c957de839706747e 6110c89446f2281e5db9b798a0fa020fad6e63e1 +233c055cc3c747f868b73686726307a307dcadbb562d3271007e4ad25520330e 1e00a3436acf0452f969a8394ceb4ffaaabae689 +2370e245ad47ad0b2c88ad121138fbe3b4931a7c9a5b2102f27eaffb5f09f892 05664605d827b3b2d88b6de331f0c39a4b9ac09e +23715dc3ee50fd82c9eca67b6bdd7a51c4c65d7508e32096bb42e755489b01fd b3e8a0abbf795114ca87ef5e714d0d2f36b84f04 +238a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a f1425cef211cc08caa31e7b545ffb232acb098c3 +23b010f4991fbff884638d5e894e14280a3f59b07749acc5c40a35d2f955fa92 40a7c27acc737f9efa912a66cbdd29d75bf44c74 +23b3583e5e642fb73f2f025263c7016caa285589bbd8ab905f7b87af6269c3b7 813b24636f71e0ebf9aaf9afbcad21518f4e1072 +23cb97c200205dc84109c248be5bd719c23bdab52b52c51ec92fef9a48790833 6fdccd49f442a7204399ca9b418f017322dbded8 +23cea2b49eed4993c5b92a9d5f0b82efe4fae3837ea707d921de645d04479015 b0fb7372f242233d1d35ce7d8e74d3990cbc5841 +2470dca53501f9587cae6103c471eecfc8089cadc68de24d72eaabb17da90f51 1ff4954e2b4c365a517362e7a9b285532a79e52c +24893e425252bc0e02b5f056663284f32bd3db39f8ee746c54835db081369516 1a039633309bdb88eb5e6c46d1f8c2ade51f09e6 +24aea63796fb2d407b9f1c63d19dcfe927f7f26af79966636c957bdf7dff58a1 ebae795e1fd8502328b176c3f63a4320c91de800 +24b7406da6799c945658578a2cac92132d7ecb27d03655c05ca8a6eb5971cf9f 3e0fb8fb56426d4645a50ce85fead9ad93ce59ba +2545649a60be2cd66432e449bb1e0ebe15a05bcc82b50292ed406464e4e66c92 1937579fc4f2bc5d813f3c8b77688b37829b394e +25579ffadad7d6abcb2a12feb00a49c2160a35b6e2806adf77445a20e5a90b1a 4c64f551d91b63e8b58d08d9d0674e1fd59b2afd +255a9457976612734498fea47aec5875822a07030bfb87462afb021e7caba0da 9db3e7f23c37f8764357828dfd6e9ea4a58365f5 +25648e64000f520ab94d539a63eb0fe4fe2a32306a70a9ae5b32444071f8df65 982cc52d0e7c0a9ece1606c37d6b8d00f682f471 +25a4efebb38c55b8f2309ce5e3116b2b9287239952cc2fa174074e05c6e5875a fe3a6a42c87ff1239370c741a265f3997add87c1 +26149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b204707bbc546a1a770ef6ced37c7089cc3bfe6b +263939ccfe22fbd0bc6475d50b830395233a3417bca1fe7d1e74c35e9292f723 116caa6ac8ce8e28cfd7d2eb29670554cba3a71b +263d72fa5cd7aa029340ef5e0bc8c409aa33ff8d1f5a4054919799e16c4c6967 46d8b885bd65158e8cb53266ba4b627b5991bce8 +2643ed9ec1615eb7e3504de7e9365473464cc93211b953392894f4e262d9f55c ced645ea9ca4170bd75c17cb9c2c8f19f935491d +265b89b438f5161c93ce2d8346739c1f0462bc9688a4d549e93f4c0b03093ff7 02283e8165fe86c4974c7082aa1c255fc07ae3e1 +269f91868728e97e447d745490b0e7418e8d1bb6cb8ee5d8e766e1ae9a559b62 28c77740506e6099df65d8c7d40f9800c9574068 +26a2dac21f8f0939566570e48f7f4fcf89239c2746ef8d3dbf31d179c691808f af3b99d5be330dbbce0b9250c3a5fb05911908cc +2726a64752aeac8c0bf4921a99e722dde7cebe782428c471fbb8dad1b2784b63 9469a286a2240165c93b1940280a86802daa5f85 +27783ad60355fe63839b8ab4d1f4e74675d2da204757b708dff7038b02bce77f e71445c43ca0d573e2f61300e454ceee357624b4 +27a8b0bdddea1bad3b442452d2cd2178ad738d0a595153f52a61b0759ce6c2bc 1a4bb64d48619e2a1ef0106be89bba17768bff63 +27db440f99ec1ff5418253bd4f354807842fea54c31053e2064de6ed0a45638e 66108a6375b0a3572ea897ddcf4470534c6d4247 +28129011003ebf7100cd50ea6bb41f61d88db419df95564bf4252aa70771b7fd 1ce3f92bf1c7b10aa4c76d1fd51094641ef53cbc +281c36286eab5e534f1c2121a4cf2cd48a32b3773a3e78df500bed3f3c9747f3 fda23b974899e7e1f938619099280bfda13bdca9 +282258be802767efbdf8c3ae693049d0dd652b161ed25c75b85568bc32931ad4 e0ed676cdefdc14fc274668b67ebb2be310fc2d6 +28772383fe514695504d51d0dcbaebb5af526f76b3e262ccf54fb3b6001a7768 209849a44961d4fb86fc51710affec6d8c407cf7 +28aec9a4450d9de98db98a021f97026bf12f1328f66e53319669eb5adce5ed3e 4f6eadeb08b9d0d1e8b1b3eac8a34940adf29a2d +28d4103b9d69469f94bcc9b762b5ff31b05b404eea961bcebc14e320209d9563 540240e7bb85dff664406a35eaeb222890228c0b +28fc5830291e38452b4b43c54c5d5a7613ccb39c4866de51b890b55cc35207cf 98fffeb8462945a9c9f19d6e8bd40470afea58e0 +290d84a2cf108c074d3764ca8dc56e1215a5a7482837f098dff7a55e23d89d5f 4f9339df943c53117a5fc8e86e2f38716ff3a668 +297b1f32141df100021efd1a47d8315833d19d47097fccb14c80c9217d8840d9 ca481fc4f12cec56b71bd50ae72e3f088b69021f +29aee3837e46aab84222310330ff8fd255096d4a22be608ddf847df5053debea 3f61a75703b0430062d1908fc0e3e682cb8b95e7 +29af12bc8b8dfc24018ada712ee5727e1185bf8db62cf5a0b693ec59995ced37 a2e130b3f5a8978bbcb28cf5743d7672c5ea10a6 +29c3d5b0abae694f9694c2f7f63eb20b80de152886642e5d0f5282b4792cf84c 3e89665eb6d5ab75051dc59fc8b63316908b19d1 +29c86d618bdd9b53a1df6ec30dd246a221bc2670aef3319b6d688a1965a78e65 4141dd83e5a7b99c7f2fb295709e2ec5a66aecc8 +2a23921ccd2ac045bb0bea1a077d8834d23f2c5292284511cc2ab2380eb5925d 0395b97d1e2df4bc7cf46a9a82b753a8908157b0 +2a497c0a14d1f5cb4d497b659b5ca43d2abd353a35ee86aa5ebd22b79e5b48e8 abf5681c033e83f92198fdce8d30c799a6e42af4 +2a53e939a3578ca6e258a421658d15fc90a4bfd310f8c6b1dce41a26bb09e2bb 4730b7224276579fcc8fc7fdb9bf796ef158fde4 +2a6348df1ac5a449ad2de13641b2993f5707c5aa37ec0108bc02caca9d93c4c6 dd1a5b5b3b7a1e3abd956a0808675001ee06347e +2a6e55b7502ae9e503aa71712eb38a7db4a400f3476d3c8c91b0de39bf4a050b 279d8e37642a9aa06a4aff44694ab7a6eb68a60a +2a744551456986934ef43201eee6334a89b1ae4e4c919ee2f8f09f893a6a1c51 2cb51104bbd83bed39bc8a178ea172b234a3d55e +2a7492a020b054d3af4f1c6ad11021a153198359f50989c9cb2d3a58d347fa8f 1a57ba73220bc222e2d290820bd9f4157c8a504e +2a7adfdbe35f2b25328c964f8e40855b92eae773accd60a2e3aa1717b6b70341 a6a1a6fa11f7d0c989afae4695d4661514cda8c8 +2aa41eec6c80ed40eeb14896e1716f9439c6a5e99725168bef1f876d0e48ebd3 12b66564dafa01d8a13b8ecf53474b1d305ea771 +2abdec884f1cda652bc5132328df25b97083f3c0d4527dbae2aacdd789ee134c f31fd16adbc7a2165c0091c22e89e50811f95df9 +2af226bda5c9ca85442284f6c50145bc14e632bf62258127f56c7ae77d295771 40721f6b1297f2a48aeb5c9a3ac095767b1153bf +2b3b4a4a848d85bc2993d0a7e3bb36e354b5053e7cb6165dac164bee2dd9712b fa19c3ef71b1ec077434b0e08bf0757ddbaa22ae +2b59f9fbfad86c6d61e684b441eddac921c532c40dd645884be08058db3d7fcb 8cb3e7d4c2c5ae36a7ec398299007af302bab6a3 +2b72c9f2e8b8a2b0e041410a14d94e9374b1d8fbbaeba9dd02dad3995d5700d8 7c982100f3c7b81e576b552484d58470631f2cbe +2b86b328af6dac7919c87c258ed08cc08fddfc033eb0c8c197c45165ef435219 b7058c66c000c55f92fc4ffd7274a16b41b196f8 +2bc0fd59c1b97b08b6018f1243a34a00e0aa32742ae2319c07ed5bdb3d9b4269 e5aedc0644f6be56bba890d932e552cf9e08e717 +2bcdebb6b95252485caa69957ca19c85b9c4f99ee36e4292a74c8505fb8158f1 158e2b76aef44441ab2bfd42ee69873822a4d67b +2bd621e4518cfff39970c47c32f704838519c36d67380758666e19699ed387ea d54b77f23f9cf4f0016dca8ceadeed48b1ad5686 +2c045ed1bfe1436578328ce00e3d7b6cf2e80742ff260b5c2b524f2dccdf97c7 86897ebdca9adf45f7789399e9c4786d819e09f9 +2c0f52f9ae1f34f280dfc1c755cbfaf2b9968fd3bab1f1eb16d3ac0fafd71940 8fac94df3035405c2e60b3799153ce7c428af6b9 +2c2688f8f004501fa4917b31de04513365c6ccb796a9319862e0f6d8ced5dbfc 0e46b1d04f022804f08de3466b5cb6b91fd366c0 +2c97e388a515dd8871f47fee997fda7ddb7626f68fabe2e2dfbed0d9e5410f04 13ce9f1b96279187249d56cc641252ff617fa35a +2c9b933ff2dabc5a043061d2aab80d967e41b01840b9790a87c981afde9bc0a6 a256495f5eb22ac2e5de21f37b22ae3c497b3580 +2cc2ff33694c392abbde2169365b575e662405af09624502d3e151d205d50c25 e6823108533f65740e0e5e75d0fc335e97439b75 +2cdcfa2499b832dbf7b855e5a7d210d538be9674dd2dc3ac301a21783eb7b333 c7f0591ff41fa0633796122d09212d3fc325b4d6 +2d22bd62fa3abdac2de06753deca74c77bd2f4a00df6014e0bba6507c076d6ba 3dd02e2850f34d7bcbfa3ccd4e909867dc89598b +2d851572773ae43b2bb09543fea4f36091522c46c0a9c494bded5cb3d0f302e1 f82a8eb4cb20e88d1030fd10d89286215a715396 +2db6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 dbc0be625bed24b5d8f5d9a927484f2065d321af +2dc5fcaaf371da4d552fdcbfb79da7a4cec2792c823c9bd09a90defaf73b437e 698d940f85a59f00286c49af24b390be7cd8466d +2dd4d7ceabcce385003eaf8bdf8c53fbc262cc3dbc2041eabc72a7fa4b6ddf1f 0b8979fc62c435ff5b984d0c13ee42d7ac2e03dd +2def5408c21e4c0611f22321783bf0d4c21f8a9006a3b6522cf295f493ec34f2 5de89cbd8c0a0c8bf4fc43938f09e58936b8c2c7 +2df3172408416389faa2bb43248e82a2220d09c9f4b56b1d2093286d9a53843e fb20a5a4b6185d9188d82c874db3d9729ef31f3b +2dff3f4b2fe826157fc7c3fc1b4c9736259160f718bfb7fdb4892bed18378c60 856017fbf64464e3797689463e95d75496c0d554 +2e2aa456dbbb8889923eb6713672427854020298a764967c50235a9a76d7ce4b cf5f7235b9c9689b133f6ea12015720b411329bd +2e51a5916d344edef37d84ade43e3b93524ed39456a7ea3054bbdbe06e2534b6 d4191884cffeb8b2481197c4c4b7dae933493174 +2e5fde11fa87cedb853bea73f5ebcc9ed34830584c5a7ef74f083916cdd4e900 e896d00181e2053cf3cf6441732a13f6ca83f104 +2e900cde6077a860354bc38e8ccade669cadf2cdfa60396a3071215c5d32cbe4 33a790ddf892b1b7922a6bf78e4362965c7fb51c +2ea5535daa4731ac4a94a7551a891f08e3c6f29cc2a864be5b164652f2f53630 11f76e30c38265404b042b0a4347e86b66132713 +2ecc823b86990906263a4369e86108176e5971872da7307b73c46f4ac7ed8a38 9890c3f69ebe264206de411473f6220fe2f9627c +2f18dee4a944014c0e20e1a96046373cd58710db5cc74b584ed7d96a324f998f 4188d28f1c38240392d896fc79561cc461fb12c0 +2f403b3668fc75cd5a4b4dc572dcba3769ddc02d13bdaa3e1c0a144e976aff0a 6586dbd5849fb1369f4719df685763ed9ba48d5b +2f468a1542ddd517af3dd118fead80293c5c77790af57e351189155e96dedc24 7a2b79d3e2f273750e3855d7a0b15a4c6acaccd4 +2faffb9919a0b6717066117ee9f156a40371e8ba0eb585170188a65ec89a8082 ab5685026cc2b70c18e2c43689a57944eacf59ed +30312e4b199c64d45ad2bc917e2ac5364ca8f8901adf7ebd1492b7adc21ba915 e412d5a411cf4e9cad80ff3fb315c42a7e718ea1 +304352ddad641770fcc94ee4d9f957cde7aaf4c107dbf8b5ba14d543640bf7dd d0e7959d4b95ffec6198df6f5a7ae259b23a5f50 +307109fcf8b70083d2fb902f2316b8a0f790c3d9f73f7870f4eb774b00bbf44d d8603ed901d4af4d0d2b493d1164c74eae34f147 +31138d44b7d0bdc213b18a0845bd56025bd976cdbc1fc323901e9c50238b30e6 81723c22eae0570f3774ac588b572636f34a7467 +312f60f6c352b8c7367e976ec359c92196d0b17d491066d47279d4e1e2f44cad efa59b726a6d367badc5c39d83e86a1664616da2 +31ae8919eaf87822e8d11a589c35fee500b0d9ca51d0548c2bdb99d4fb299310 7c6be4f3fc4d952d4eab59ba2e553c6b77725bfa +31b05c73b9305a342be592d83d59408dcd54a5adc94f0da7fb6dba61acc2929f e719ec29cf9da6022610b46b463b80d393d22778 +31cbc27193bede4e2ff534542aa46c1a8ed7c4d2f5e9c9e462bb99d73e5f7691 c27b446edd6db301478ee29880aaabfe2bb66539 +31d5e6deb4c8fb548582ca4d37fd37f2605231277340f5b402fd64904c542ebf 5e8220f46ca2e7002bba745d8c0708622c64150f +31e01e45015260b88c5131254e3a3f72df292442143d2ae03224d61aa5177c24 8ea17a2c5a5bbf0f5aa72f73e6f980136d72e6b5 +31fccc3f5f0b0e514673895b4aba0dc2a54b7bf1441abe8c41b348ac997c5566 79038fb3d450dd7b37328281a717f275cb7eb7e0 +32ec9339b53b2bdc73e027642a1c990d3ada79a168de1cbcea2afd29fedc9709 027a51a064c6a3d91392f31f32b041bb1920ec60 +3302d4fbb5614b19c697d3f3bcae7ff785944cebcb095ceb418ae601dacfd986 75e6d95a87b9c6a5683a6f4b56fbfc9ae6e53a7e +33139bd70082e3948104945187410076178d57d31dd2b50542b9e2b321e85776 e65ddb38019b6e2c268f8ab9c28eb19bb162b032 +3315093132a8f28bd202c0a9562d04eebea4943dcd1e1c754341b0389722042f cfe3a027ab12506d4144ee8a35669ae8fc4b7ab1 +3317ced38dfcc6285ecd4187b6fda9e9027cd26fe11a4a81e537e770a892745b 39c222290d1392e028478037e250bfd215635cb1 +332d62e05adc040df538a64bb4cdaa02cf5bcc83fc8a0c3a19081be7956fe1dc aa0c0f471d53ead366e80077a9fc82649edbb4bc +335633f31770ec3147c2fa9305b5eb1fe95372bb00fc07b8f5a28d0aa40e9769 bb61d8117a8cae026fe4061e15c29a96aea3496e +3366326706d1691a8e07d043d23df3a4a96945bf9377cbe95d4ca9e695ae34bc be876eda8beabd473360e2dbd1a2ae5e80f6455e +3381a5bc62348132331d43b4c62f99c69e9d927072eb35fab9f10b9911d805de 15595ebcc29767ee05eb33adb216fc2e92af85f4 +338aa6b9127d19d369e1973f72e10306d02fae93bbefe85e40160dc40417db80 7aa92d44ad52b314e335fa1aa45096ebf284cc30 +33a9bfeba76f77472d80e57af9f6362744595f3dec1fb9e011446ccc43f0db0b 5d7f65df66f2bc9f3581ecb1a7932b31b8c98aa1 +33cba02acdd63428702757d61751c0dc47d51b011ba0f006774a2347763c5dd1 089c2d931b6b68dd82527430da51881d23bbd9a6 +33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 1385f264afb75a56a5bec74243be9b367ba4ca08 +3447c9eb6bbfce8c4048e647e17d5c170564bb373efbafa65e3f2c64f56bd7f1 5dddf7c855f9c8e43954a99a6f85c098dfc7ed41 +345d2fbf1d306c7ea46a05f497793308357e9e17ab0e866446d2b9894378ddce d0d7e736e536a41bcb885005f8bf258c61cad682 +34e4e17c4c3b2175b0c8eff812e9c3c6bc689829b435c0f529cd73a69cdd7f2b 20c4a63e8cd8a70bc0f894ada6a54afbdefffadf +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b 849a5e34a26815e821f865b8479f5815a47af0fe +35511d2821ee472ed03f36d2e481f6d1d47a85d03ef56996b67f43b401e2732b 7a750b897cf8d5321db7b7f8a06e7d098b13a74b +3576c3885a36e2e498004c5eb560a8b98ddb87778d2680aa24bf12c2a34a8870 e8d0c5322cff755bc73d89db95334482f920ccdd +35f9aa36440bb182dd897a1a2c212fc1dc45e17ffd5cac859c87ec4ded0a36da 698b078c75c911b8361318db385d70cc84543a13 +3609a41c0506fe19d01fb8b4729923362675f191fe5f63fab3111ef804c48fdf ed1ea164cdbe3c4b200fb4fa19861ea90eaee222 +3612a2a9b865800bd6450c6cf21330676dadf843a578eb12d2e6cc6092ba3eb5 088a731f00a39fb3158dc9150b7c8d176df51867 +3612a2cc30e97df2d2bc86ec0aa57d7f332642cdc370d2b0df18eaa6a53bf220 0474870ab94adafa0bfca2fe128d6ea7fa2f3c99 +36693b61b675ecfe1babc324bbcef2e01bee0275b422152cd8c48593555d27ec a57e9a8cc15b61ae1ab908b362fd829b3e36e513 +3669ab580ce27ccc1dea9e89c70fdc98d0853d961dbac4dd0d56130f1784ac12 0bfeb8244a6a16625a0b6df594118e041f16a185 +36809d2768524a8d74cb2513e3f0e4d07e765b54230f7dcdde40298fe58a90e5 e3059f59ca36951d3817675131aad82c626c6d97 +3682fbc67dccfd36dc615ba17e3ade5fb7f1dcd6ebb425104317593be72e529f da5f70ee04085d85be124739bacefe69e829c0e1 +3699821b431131e6a684f5faa9e940a1097dd276bc5fd41e6a9f9424b442fbf2 098db3d369e28b5e5355db956df3fb45241f4feb +36d63bb74fd24718c0d6113c70db5bc718357bf0a9b336dd23e0a08a51fdfe6a 4275617b02912a72f62ca7d2a1b8f22602af4de5 +36eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 270b8ea76056d5cad83af921837702d3e3c2924d +36eba302d2fb99d0b1c79bcec1198f1cbba6cc8c804a19d3bf2bd3883e5d9fbd 4e0d6d864d3632a820d8bf3dd89ff333b9bbd34d +37113624744ef096dff48983ffb612b765818092c6b30fc0756f22050e9c9cdd 03c3f39467c727707a5522e6ecdb4fd2ef09f8b1 +3740df04c191176e7dcfb8ffc9eaa32a49474fad69a959fd03a1234ea1e5dae0 5b209c9654c83719b07d9fc1d2287ca361663fe1 +375f69d3d41e36d6904bfa86221690ec49de2a030664a362abaf86c426f9f7e0 df48000ac4f48570054e3a71a81916357997b680 +37930b649e0a232d9d5068e3eca85924117dd83095ee0855e2e9524fe227ab30 864af6d01aff80a76f16241ceb82c74d9df49e34 +37a3d0dc04bf341eba75c9a147cda7995d68a8f9ff1c7a43871b9c7a7e3a9ff8 e24efbdd0d24660b10a736020ecbb98453bcd99c +37c7c3d1205434567f6127eb53c246e5760f03742e2157813c5809152d461491 f15b75039d7d4db8e989b85fc085e6f1412ea318 +37efd2fcbb9d39295e0c1521d7a4c53b9be48cc20028ebb1718aaff90149ab2a 7e78a9c8d5aba74a0c85d77ef590a9a9a6426bbb +37fd90d6abe96a2b664d80443bc426a3d47ab5d60c68e06b29bb32b82c9c702c c0d11745152c0a3bd8bd0e94a8996ac952604ab4 +38245b6deef0fde5656f71d86a9d89a86886d42298e46ed740756281cc07ca18 4638c830017efa737b74da9e55236bd515ac569d +3829e422229d9c5b4bc01df9388483e29b4e52935c4cf4c531904edf80f012b7 375649f879c2d828c5a10ab61992e5d84c016dbe +384d76a2f80b78ad569d3619586c957e6dff985e2fadfcc99f2f58e4f1690be1 9e2cd50ab5fa56644adcaa13bef9e3dfc7bf8cee +389af1fc5e97b1e7d9cb01b1e387b08862e26d67c3650788f51b8714c9f5fd6e 60f4720d8ef4cbbd09f7f9ad8e41bd77b4814cb8 +38ba5ee9660e8ec8b261e2edb1441987798bdaa4f19d478241a76df16b88d0e5 dea66ba25c0b724e0dbfdf494d50f7f3f2ca780b +39bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 b6361fc6a97178d8fc8639fdeed71c775ab52593 +3a0a4805f179ea4e115d542497fc755a2c1ea5792853609a25b26b299553df6d 684a1d3d44cbbc86381f61d4d9305012799d9f5d +3a0cd33a47fcd0c7b8f8c1d407aaa53f648e25f2ffe2533a7e9c09c3d1b9da75 2f9b6b6e3d9250ba09360734aa47973a993b59d1 +3a103fcd415b1565358ec83f4341844d2b4cb68e1db409778a7604cc47ee8663 92ff6464177928722632f05a3083dfd9c5dcf47a +3a1b33e58ce33cb9658a2ed1cb6215a4120f4d8d066cb7f4c5979db9070fa59a 1fcdf832d88aaf0f7abe480f5636d0cea10aa109 +3a32ac3a0452f13635a41fbef02879bffb3733491b4b791fc1766b6f208acb59 3a612bc5fb913bcd8dd90fc3042f23882d626a91 +3a3735b8a28278539697e5f6af5c45670d526fb7538ff1594e99df6331c382b4 495eefc6e0986083b95f87974942afebde688173 +3a70044491dcb883ea825b2e299c512f1877761862d5568028f7ac185cf38604 17e194d81de579d956587ed7411eeb77f88df277 +3aae8af9b31d378f55fe8390becba6e9d7a4cc07c2df45fad2289083bcc090cc 12dcefefdbc9972cf851906ca5c8e8fea46d1fcc +3ab0a48f387c62d22abef3b52bab7bc7e41a3bce649e573912d0de4c79b68af4 0aaf8708b0f67ed9b99f1c1e2fd28492a671123d +3b1b991ae70d1f5388ad16b63d2285e99ada7a618c6f5d01e50a6d4b33c4767d 2f06098183b0d7be350acbe39cdbaccff2df0c4a +3b58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 f0a2a10243ca64f935dbe3dccb89ec8bf16bdace +3b76cee4a13d688c4c7f83c2394d6a0b3908fb4289d917c439431d85e53e08d6 b3e014dd4810983396c9ab09edc7be1e0ed1ff51 +3b80aefa5801cc70308cfbb6300e7e04f9eeaae97703e0ced39d05f6ccb3a552 a74605e0562a64dd538a56a3f29ea85322f4220b +3bb429f2e42b885e937592255fa2da4014dcdc63fadfcf62413f0660f438a85f 79ca2edcd4e7a801400fa33c2c705b8f03a5d7f5 +3bba055be795e5d49a89496f0219ea2f43cd9eb6cb084669eae97dc69bfeb459 a7f70745f85f445596125cae6e357e84b84cb925 +3bcdf0dbf3cf72b38fd65d0dbd8d6c6c4d9e3ddbf3916f03e1e6e4de72785c77 20d191c80cedbcc63ed52096b8b0e180c6bc16b1 +3bf9e14c7f197bfefdff9d52063713de4bff0b857f53b799db0f4050bd62d3c5 52f3dfe9b5593c9dd45980c36e2499f2e9de701d +3c75c9f9f003694aaaff66b2efb4932dfb0216bb85d6ba5500d6f4a05e92b0b5 eeae5bdbc9a3075ff9ee6a08af804b5df11154ec +3c96c1697a81679472afac3dd2723abe86f34f50cb2804eece8b0c942b3a6d9c d4d88ab7e48adcc92099c41b7a5e85d580f9d77f +3cb25d62ced555f8409804796b32e06540c096ef858ad45c864f31503dbd4982 e3409fb59571d2eabd07d4d7c09a0fcf07b6cc5e +3ccee1f77ce4b4db6e6ec7162538efcaf479f3ddd950ada7ac800abe7e9661d3 fe3c74b75812f161cf1838602ad7567143bcb593 +3ce006ae57f23548f85a5527e5cfd9ab29ae42aa1ba90057a807346404f8174f 94f7fb59f74edb08d375562d1814645dbe7ffcf2 +3d14ff2d57c0186871a99a497966bbdcd17e61c41739cbeb860efb0f7be31c18 dc5b2ce5d1c4c9c38b94af511ba60946b8761681 +3d45b4ff158011774b796fe55f7041f932df6dfdaaac2dee934a0b6f2a2e5d4f 8b049129be2405e428a3bae21ea9b99387a96afc +3d47ad957bcd83e6603d706016af1b6158878b32c902fbc86d28918d640feb0c d490452617988fed2ef9cc3ff667396532426903 +3d8632d47f3f70b96b9391e692c79b6237506bf999a012e50c1c3b15998748c5 7fb15ecd2e65e379b6f3af1f25be0024c0be27ad +3d8a6f490eba51281c43d4b67e0336a2947896a4bfaac3c0449a7dfc84411128 1e4ac7e37cb4d50c35b7a52202c646a81e5c3dac +3dbaa90e18232adedec438665cb022c35cb97c999ede79097d3ba17b1810df0b ce4344fa507b0c6330a3559850c9cd186d1b052d +3dbc65bd993e6e700790c5c51ff0e0027b55f55699293e73fcda7c5e53a8a3a8 1b6dfa9817a8f324f234f0f31cdc79c016b40264 +3de437349b8b47ba5cd83d5f70956594de271cda393792922fb2416e3f327f5a b7b0d0ed2d91c83b59914db77c3dbc34e36e2c0a +3e00d8cae2726dc33879adf876b30c306f50e7a85b15c8add4a27f84d88616d7 1088490171d9b984d68b8b9be9ca003f4eafff59 +3e24bd404d914a9195b89466b1801a0bce6e55fec958ca7ca9a778a08fae6fa2 010f258ae4bf72c23d01e8902d7f5dc8e4533ab1 +3e29ebc6f1b56a649256d7c35fc227c530f1477638fcc68981b3626e49746928 ac7d251b493d022de34162880d30392aaf88cd3c +3e5411e6190b46bd834ffe79f2bff3fe5a9f99ff2d4b5520bfe84cb22e295b38 6624a3e24af09a12acd9b5b98c3109fca580410e +3e9c52a7e147ac9dc1a9e23ed7193642e108276f5e74397201c630bc1dcf20d8 c8df0297553b2e8c273ced67b3bd3d1603c9d4c7 +3eab74a6894d790767f3d92615a6887dcccaffa9e48fdd2ce482b5f17efcf9b9 111d5ccf0bb010c4e8d7af3eedfa12ef4c5e265b +3ebff01bceb09f6f4e2a24596d6e281587981dde381be64240283c0d161e753b 64c993e1ed74492bfe41ddfaa8e5f7999b5b3952 +3ec0a36347125293ae217e7d4049dbda22951ff9cd0d5207118f6e963a7428d5 60ea5e87d97ab72853fe358b4de61a68ca7a3908 +3eee10d9f6089f9d03d64c65b9aea882217f833ed9538e7dc49c2ff73ec9e41d 0ccf3c2464ea829a6320156b5ee131337898f2cd +3ef82d40c8f2f25a1f20d1e459d083eba406bad227af5881c6fe97aec74ca7ab a0b61b552c08fb538365870b3ff49d936a46c21a +3f0764d48b89e7d99138b291b09ec88b9132fab0a60de5b6505ff9d9b383e843 8e9e423eddd73420ca4b824f54211208f33628c6 +3f429bf36329d28d40103a6b1813f92b8322bdffb7bd5943cea40569196e6838 eccaf6f8e31a3c87b89243153770455805ed4c1d +3f5dca26a2f512d6681ce1957b8afba5e031bf63d52fd52d8f57093bf92391a4 7033f9ee0e52b08cb5679cd49b7b7999eaf9eaf8 +3f7fdefa5ab3f52b546c3cf59cd50d61c29efbe4a2c40b1d5ab8e50ef34fa398 3aed57726754bd5c09bcd425d9b99add5db50a78 +3f838c3c9c70ea829eb28dcb763341b8c730131251979eb1f60ed6819f6a500f ff02f4077fc8420d328c8b91c1f5b2e71a7c19c8 +3f881332ff93d2176b18dcd38c990146ff160b3eb83a262bc77462edbc246a32 66ce77617726f19d295e56cf7de330c848325646 +3f933cd9565bcc7b8be630d5626c9dede75c7aeca14473b2bc2b88d26417c7f8 29f0e90ff41bd7079d3e620e15370e3a8385884f +3fb315ae00172e2f6cffb933843a407277ea426015fa6224865a7c63ecc37d8f 2dbdb824f0cfbf5f583e6b94aec753f276ed3368 +3fdd086cf7ac8ab728ff01b763ad65b9d1b7122580d88aee652b8ced232647fc 175396917d98ba13e5bc959bc3dc237cdd492036 +3fe6ac134c9e29c44bef2dbd0b11718e203347e4b867cecdedc20e3466bd9896 69dca959508cd04b226b3747c0c07f89f3bd1a87 +3feda025daa440402e3c020cd88a0e9378dd2442e55ed409c466376d5b424730 ea790f337b0e401f5e4acabf9af9c2bc756d5f3b +40154096dfe3b0b1abf64230345d327bfb530fdc2eea093d407bc245a94cd71f d15e94c0d4eb0fe06dd1e25d7e9e3c4940417f56 +402b3758191ee821d652dc759baf30a8949a66e3b7d073e7e79d91c053a7207e caebc63b34886497fa2b6ed9814a327d3c91e545 +404b795df44dc8a0830397f7598ed7383ffc5c227c2c8a2223bcf9cac3e6a4cf cb98fecad0c4379496f32a3f7ce3aea2ca553b3a +4066249c68b0d3c8b39ebe02c9188935900465acad02a49269710f56720fa58e d0fdf2dcff2f548952eec536ccc6d266550041bc +4071ba3d3cd2494d4951a322550a934507c44cc7278c90d5f7458c512407fc8c e58c5633474c35eb16f9dec209d57aaf881b97cc +40799f33b8cd9ca41f36a2f89d8ac8550537ad01dfb21fbc76f01eeb62f512d4 bfaf8c42eb8842abe206179fee864cfba87e3ca9 +40c6785bdf24b49d3b75f3f1f918dcdff55b2a001b66afd0a411b3e8439c9066 979709bdbc7b1c91505138e1aeab9f8b714480ed +410cbca5119f2d6f16c3e42b52d56148d5f72d45679c92ffa3b6d9a2edb756ce 80176fc970e2964677967ca1a2a3689364513593 +4187fa8d107c1c86d8615ef4712f1f7c64829749a52a1e68c715ad9a531a6e2e 33f0f5ce19ce81d7d32752b140dd9f5871d72eca +41aa03e11a4af5047dceb683d7a03cdeeb904c85f8a58464c99709defc5c0301 c45579ca160b99e14290db789f3c690c406b6dc0 +41b613b0200cd70a7f5f0dd85a98cff80cf770d2b69e3a270fda0ed2ea9e3577 4a9c7f5656c7c53f5172e16174b96ab44606de35 +41c166c241a4e878f444932a193501e12ab38ba0634747291df70e619dccee1c 3188ffdbb3a3d52e0f78f30c484533899224436e +41ddb608f05a0551ca421a4c6031f9f0b0d1c165d8268462155614a741db2f50 ec66baf57304fbc94d8b1bf55a6264b6a34c5972 +41f0c76d526a391e6642bf1724a2f32c926d1d10262aad6183d7cacade456c87 cc7301d8a23a16789de6d298a6b1d2ad7c686184 +42582993ace8a3488078298b40b08e2e48bf576ab05b1bd36bb4884a9ce853d4 6add857acd3537b186d2c8d2c0e3027c364872c9 +426317ab5167d24de98d3d49614d713fa8e5ba435e1d9600c3b95d2fe9f2d785 f3489977f6f6d5839be9f17118bb723fbac74a89 +4277a22c721ffe0b89f6fad5e7779f6fe80a708bc471ab49bba329d41d5843ad b1bdce4f69d6893727df16ed00fed96d701fac06 +432fa95d99227269dcc7298e892e53873ae8b6a283041bab4febeb298fd3ae10 eda57c53e981161ad7cb25103fbccb31661181e5 +43630957599e6247ff790ed2a0021c6dd072687ea8952d64b767251f79135d42 53d25eef40016eb27787814df58e0b56e76d9326 +43723656763f3659a5e094a87df27c5b43d270840870dbe1734142e2a9466d7b 1711eef6e71be6d243016b5e138766b3777e08ef +43989c902407cb7bc3753f4338f4847b21f53f49c4e9f750cb866507b64ab669 b438016ecda7648426036e66c4ed17fc93e71cfa +43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b 4a202b346bb0fb0db7eff3cffeb3c70babbd2045 +43f15e413a5b988bfff18d10d4b3bd546b13084560e0a723f4500fc094e13558 783257d3b6a3279dc62d194bea3b7f301a899351 +43fc14cd889029d5ad6e285b60f162e73c9576d49068607e879a2a0e5127fa5a 44b6a517f15303e5ca4cadb090c2ae47cbdf0c68 +441eb4d681a9c013e67255dd2fa2fd722863bccb7fa9d9a9230b7aaf5f107ae0 47b0273228dd08a6ce617f8f3ab2092a2d4dca57 +443f41124cbcc448cff03bf4ed757ad88a5f5b711f761764bf37c64f7e900869 608d33fa676aab1ed350312cc07e02cd7f94847d +4481293fc62420e43723b5402eb6ad4042f5f2951f9c9413c4ac3235edd4553a 08167bdf6e553be1acfce09de11aa69b1c3a807e +44be0bb4fa20d53c8b321492e98794e9054b66ea200d626b9d9f8c990344b32a a41bae0b8aab4991d9d4bf9cddbaac3c6f38ef9e +44c505e4121cbe40d889b39082f5bb700ccae8e93019335df7242e6c84f8e2dd 13b8725687aa88dbac7a9a34865984d6fa68dbbf +44db3dd46bf12039f93ff4752baebc137f2f638089fb0e1a217c99528c3602d4 9fd8412e652899d03576190cbafe0ae194357827 +4516b0e63349c81abc6584cb11ce84ab8ba38b105f9de39d0d0a1455dba2478d dff79e27d3d2cdc09790ded80fe2ea8ff5d61034 +45b27cc016ef3dfa31290c1e564c82266dfd4e626d65c10e4b84717f59acaef6 76f293894f4ca1846f52513b420dd68bcb8da127 +460ad78c6b885a65e795a6ac9a4c85d5a6083b49f2a168cf14701b1aac7ab51e ad9f7df6bcf1b6e69be44c85641380848eea36b3 +461f1d5cecafb15ce791d599ac2114b5cd320cefeaebb90732970655e6f85050 aee8b26e6322bee55403a61634d7e01b77aea4c1 +46333d32b3801cf11d9f80b557245c9e32b0e05deca61dae968914fde159f0e5 0cfd861bd547b6520d1fc2e190e8359e0a9c9b90 +46698c7215f6b45759d9cc387e8d3121ee1ebaac4330cc1e1f38358b5d67b973 9bd5c5f028c505f9777c63ea85c5399bcb9cbfb8 +466cdfec4c74f3ed4fe53165e468a52df5dff9c6533ec433cdf235a73e099d32 5052bf355d9f8c52446561a39733a8767bf31e37 +4686fa9fcfbd200774f6b6e55dd719a3eea3da7933217c7da0efd14fa9fc3242 ed2292c12cde99459c5859362b45712deb1d5136 +46cf6ef7c306ad8d79ae690f643ffbda6d1cc3481e46f4202a166c6dd141cfb3 d3b23e08fe7235ea387b45453424409fb54ab7f4 +46fe85670f28bcacc7894ef9227f4816ff018994a67425ca92ca71f58f57c5a1 f5607b58a0364fa99eb1bab8e1c06fd948cc701b +471b08f85206aaa22b74d87e57de5caf02fca30587512ffc81bbf32d63e9915d 58a948216a0b01a66b21ab7a2116adfd536cf922 +471fa4fc2da467dd94e57babb1912bbdb5e40b96c8129d46fc709c0bfc009bca b0a8568a7614806378a54db5706ee3b06ae58693 +473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 +477a19a87cb58e25978dc3302ae5f089d4e4997257fa09e259f2f03ffc5572e4 c5bf0cd945f7bb251ab2d30ecec98e982bbeb49c +47f06c894892f592fde64369a0850fd5d7b78d0e3ef825f66a064acf6781fa9e b923f2f97dc26e981c18da93b98bd5e7b44c3b79 +4815816fa5a372f9391088eb904b85bcd83b0f5117772b597691dc43fbf5bced 5df58dda56789631c78aeed62708e1b694440195 +48206be797f7ae1a97312fbc167d2f1d68a7a739844105ee0829635ad3db5001 5cb9d1b563afb84d201d9cfc98aa774d7c714266 +489243ccce2df9992af678d0bac3bbe47d19de6cf9577e4e993e036efb0b194a e6b63299b2cbc04ba8720f77425cb58c7774d4aa +4892b87dbc8972e6de31028fdef2e8ef01f4adadb782e61e2995424a4e660c1b 55ea3a1ed6a61ba508ad6f9e8b70169fbd7746a4 +48d25469668795d0d0fcaa9964a1c7555b750a8d700869d5d8cd466b1f3b0881 2434915bce998e8aec539a19419f2c50f26fa6f9 +48fc94b3d4233d194db85973d6028ef5da29aa21aed20f8096539b837fdb9cbb 171aaf21d9f7582270c390962f61d3d2613c4d59 +49235ddeecf412d250153a630dd1372fa0ea2953f64edf66f9cc712c4e003504 41e13b227932a121b8971909081382da4236d674 +494fc3881f4dd0afeb9c67b9d03ee0a7bfbdc344db53d35ca91b23b27b8a25b1 8a208841484daebf2dc98866e6d2e44bd9467cf7 +49818c2e41a63cac45e51f99834d583c2623c48a2add67395238eb16609c7f43 d90233146d40105f042773fce6917fa4687b94a1 +4981f3f393dad6299538f859bfc10bfd1a46e6c1a76991a35f66c4a63563bf74 42fd40db68e5e5797531dc1f5de7aef39a2262c0 +49a226f8527a921c15864067e049ef18fe0e56672cd9be551eb1ac520cc2fbe0 29d1016d5fd281f10d5fd8183fd8bd2f1aa37121 +49d34d8e410e2bc0d4e83f55f013feff99a8412092b44fe18c388e2cb61539d9 01ef4fad010ce3b90426982172b2d93a9409797a +49d6ca3fd96a83a837867c38d32bebffa599cd8f0e1442ec38f9881b33184f78 a1d34bc000cee6d72c3b5e329faa58424641611f +49ea7b53ee934be208c963260e61d8939898040d12b4e1c166222b5a7400eb42 0ef9d2aa934d6e5861206e8c5dd829dc09f4026a +49f1fcadf4ffce148c8dc15c655c325b0c52315f3e093ca5e60184b826f1d575 9b17380391d7e2e4cc26654ee4423ec14d379d28 +49f7c79a7b31b51b469de45d980e77ecb6540a138121dd60bdf399d0000db2da 29e77b4c60769b427a0cebf6573bcbe3b8779bec +4a1b9c078e7bb20759a2d75e3a4b96827c851446c0261750b96aa5f286efe378 cf33ac7a3d8b2b8f6bb266518aadbf59de397608 +4a2c51c855f0dae37a9d35532cca06e82c6c00e1e35cdd5a1294ea79a0c89b8d 8b9579b77d705268991880156c59a6ecf3a00e32 +4a4ebb837e3c9883f35d0ecdc26d4bc76a0f665568b08f3e967096f2fd3fa537 502acd164fb115768d723144da2e7bb5a24891bb +4a7732457b004efb34e8eb1405a9a26f66d28866d8f043ba3d732b4a640174bd 150bce88353a5b322b1600a5989e126cf8288562 +4a98d245f29b382f3bcfe34639530bb5d04f6d5074d9c22359b6c8a1d5b25540 1dd35dc8e28b539e6b2e15ea2a99d43ee4d2f282 +4ab6132f0fb323c66309c552e3d84cbe8a374258ac42bb51b727e02d881b04df 007e075337848055a92e218bdfe137451a4c9635 +4ac0a355c8c8c1d9f943292761fcbaf0f9a342b6dafa1ece1145903e2a07ab44 75d584305598407be4c53d42c85eca3cd58c973c +4ae0fd2cd8725f4c1af5517529f28e608f1dae886966739d3a6889b8722e71a1 bde6fd7aa4ede6f79d41fa5be13567d12388c79c +4ae3f76027b14d13e85f0f5498a4a697583940df57ac8733aa56d82900112a80 ec250c6e18e56d12714f9010e1b15e5feec5f473 +4ba2e6fe88717d069f04f6504a12052b38307bb7d50adf36b19152f50b533082 4a869a273478d93810045203fa44e2404d0e32a2 +4bb30c70803cdc8f5945d4f61437010efb53e992301ed4f406b0706d0edd26c8 3f84b7d30bcee174491ff0015816fe8831b1440a +4bc0f94102287f8e84de5459edd04872cdb10a27652c49499a9689fa073566ed a6a793147da3bbdf15931e03128af729b5d0c4bb +4bc142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 a71586c1dfe8a71c6cbf6c129f404c5642ff31bd +4bdc2bd639e67ab657405823281a1f4e8185eecbb81a4942278212d1fd47d941 4b09c08aefb8298b3ef03691eb8b4970ecadb1a3 +4bf5c64f79284904a0c0d54bbd380a63b7c7be4ded56619ac7aba0ac763345b1 d25c9bb2bf4c052f41ead5328a068f6828d75ba2 +4bff6d41212764361eba5a8167bc0168cb027f50724f3c53e00e2c435c92fd06 46f4e377719b3df0279e66f4d8d7677c7fa16dd2 +4c288bf404c8e93868ae54b4a9e93124c56c1c61184466629d03310065031e88 388e9c621a9deb2180cd601e30a540cdbd310b53 +4c989a75733680cdbe9068f0896f30aba0cb9c8cd4334e349dd815a2e6ae6b7c ae3a1615a8ab6b9a13ef98fb3f60efe727615310 +4ca78a50e220f784d9f0d792184efb85d2e78ca1bc8aa01713c794cb099c0cee c79dded300f279a6d8660b13f4fca3c684533449 +4cb34795575974e851198c515d39f43c8482c0f82f39518e7ea31b862168a6c5 ff5f93335a52245a405e12e9ad1091f4cb875b5a +4cd983d076e60b69cf7cc6c645f66eba7df5032d271c9ee95d74193b8e3dcc79 795f44a7d7e1728199aa9ecacf35a55d3722e06c +4ceb14f374b242ce6b94a527429bf46799f37071e59d43add03c79cc3f78f7ea 04e8824004970f6889b9df126b5db343013c82c9 +4d068ba9c35443df0a7723e96ec1eb1b0c86dafd4b6892a93491a5d818d944ad 98f3b5407694b1977ed2b4fe548831916e788ab8 +4d400cf49a7d61e1829d382168d34818c10f174e6141909e6f253142c48bc725 62496552534d8c5a4fc1839c20c33b0de4ba2b9b +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 e90810b8df3e80c413d903f631643c716887138d +4d95fd7a1a738b7b73ff5b0c595d8953497404cb61a91b787ea266450bacb2ce 1d1be8ee22a69ad37b6cab510bf5f480dc6df779 +4dd37b9df07bcc7b45ce72a44e3f5fcaf5f0a9a5f3148963714eac4c99a60388 d03f567593f346a1ca96a57f8191def098d126e3 +4de260deee1620a10ad5f497cd446e3c6bea110a5baf5b82fc510bc6ce5074f1 c620f25d7fb92598b819001c8265d0d324275546 +4df8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd 4b22b35d44b5a4f589edf3dc89196399771796ea +4e04d7c66334581183749a291a12d263492195f3418d12a06ad507705dcb8f5f 290ba2a03a1b3c4d6d76737df0c9a8964c0fc192 +4e731979325f7c7ea26f941615779e107442e05af41f66959ee130f0a6d0864b 37eb3fae578d0c74cd43af472a96e58eeb29c7d6 +4e7d3270a3ec5957db4fb47c36ca53e140252a975ae3019565280787952f28c6 8be856d8f8c8aab89f093583f091979aa2a4b8e3 +4e8061916861af6c1400709d97a34eb696efb43e9d862c53d9920fa0c71a76fe b580f2da89f867e9031f9d5dd8f58a20baf20b33 +4e8deea38a82e0ea12ef279bdb6669f3b31e1b10862ecfdf0f4a2b1c37ae14d0 96e4df3bdb0802fef56077e3f2b24fbe4b72b4a3 +4ed01278b8fd34390518ee993e4454928b40d85760ebc6fdfbc8e66e45ef7fa9 abb8a36f30d20e6f6c1ec2f5639c014e3cc18535 +4edae24c115b595fcb68ac98ea93339b9f2f168ecabacfab22cd6a8bab93114a f2a98a88cf3372bdb57d72c7136be6d42b5be1b4 +4eff51656a824127b4d8c5d9a6f4880830c91fe325fa8d213fd1afd6790affce cac5d927b51bf378cf599a02d38538cf7ab70146 +4f67cba8f2b69fb809b5b8303d82624e443647408af3466e59c10aedb2422e7f 0c7fda8e41f67823610884815c71cf47c6dde496 +4f79bfa3bbbcee0f835fb81706a3ea7264ea4ce29533000a24ee291748193d18 491442f97ec18dfdfa88912d20c2304d6ded378f +4fccb0e68f9445601a507d0ee3d00531a914a409bd2fceed6c07bf3189c25362 1ca0fbb0838e8859d5928cfab9acd749e618b6ec +4fe798a4c86598a3d39cc2e8e7cd4166f110d79e49d14fc0ce656016142b9ea7 018fce57e6ca903bffe9abadd2b8faf1e60c3899 +4fef7f7c937fa759ef00bce38f77e622a67b3bee32d6d98d50c84630e74c40dd 2bf93fa1071c3df7f43926c8e6c3bd2353d78160 +50085f68f619f133f16b57b7e3d18636eaa349151ebdcc0eac3f6de491de0828 e323fc5116fcc4fd39bbe3dbbeab1e2712052e09 +50141d4c9e46aed05c08d59a50a230e5507cf172166784d0f5bb6a1edca97377 c5696427b6d53a3f79baad35ea33c556884a410a +502a0aef29fd792e608b9d0e312dec720cd1b1bbc41a22a5ff05b5679ac9de94 6c31ebf84bd6eff927f1e6cb5fdcb4ebf56e1e4c +503680aa43ed7beea11c79ba04a43cfcbc84741e7e8b9fceeecf7eb3a3e46e62 7f12e62c5139c9c43ed54c3d44cd3a32263d245d +505fee9e489599e4e4d0a3f966a981a7aa7ac60ba8c774b2b942f0dba4b60ca7 16ba02bda9682555bec1bfc9225921d7e949f16e +50a8f69b7ad3d2fc73678d3b5a7d474998c04c83af503e57b2368a78e8e4975b 1cfb0ff4b6193c409e846a5992683559afd4be07 +50f19348faeb431dd64cbc6c14ffd04d1ed09f3cc7582d56d449cbef87a52b72 84a5237f8ce73ff4cdf8b644ddfa9f0bcedb45df +50fae421c835c89e59c0103070a489a071ad663c992308b67cfb346218d1da78 f16c489d96a9a046cddb3de04198e96b65f73330 +51555c7599dab2ffe66391540f293df885d8f5859b17b8de3bb3ff7db3832619 a5ab36d1d5a5b73d0df5425e5b0ff25eda320563 +5216691483e994addc87468ca4d0e29b4ed2d2e85cdded14f5a0ff5604edf733 3bbeff3fc22b75c1a26f4ab9b64449b33002aea5 +52cc121e697beb8a03c666a7cef327534c6093ec79c3a53babcd5e8daf5beb4e a4e23d6af621573f5e01adeae0c34099f66df32f +52dd20196726c4c9586b9fdd025af66adc7eb0373f5c62aba864fefb526cea55 64a47c01426a36cdb7e598d17018d5791e54bb97 +52e11d5ceb65af472f4665ebe312542aad2b6cd032093254539db22126f7f7e9 1906f2369d2906cfd4affeab0852b67c4a91ddca +5327a985a8eae90deba5b4061d53c803cfd87ce7d5b6102b6ba8a440f1708a8d 32d5e64646c0c3a5229e2008e21a45a741e197f4 +5329dd2fd8557be5ad06b57882cf42e23d767cdc8a4b25e464fdb00890649e07 af795e498d411142ddb073e8ca2c5447c3295a4c +532bf3caadaf4a236b802370418cfcf91668947474f540cfa8cfd54223435efd f9660220534f2ff457939a16634bdd5bc55b7984 +534f1da60db89d7c6279315acf64e3ccdd1d2892938f9bcd0ec9850f127bec92 38c513b9d1f6c19f191927003c5befd2fa70da9a +538bde541f9512cf48fe308a110a279cd36ae036d3845db0bb7574832dda72f1 e667e1741dc49767b8563796879f344bc2b08197 +5398744baee56c62882d02aea2750298ac9f54415fbb62894d246d9c0a332676 94eb865e6b5e041f6ca6ad16ad102ece39ca3482 +540354213f70c39f4f6e39fafc65ea211a96e6925403a3857955d42097f52e39 8839d5b02bf316795bf8716c33efe255c3b6c8cd +54139ddc224333e61424ecd3e0d1d3657422696d8215228bd5b26db14f63647c 0d9380246ef66cb3702c70bb9c1733fd200739ee +548f39b3c94981fd63b03b135f58b8790e2acf91bcb754546c7ac87820fed04b 425aa0032cbe69c0ca70f1467e54e862fbc572fc +548fc7632f9b3793ae8ca2f9bbf4c60d640973910cdf5567d252d5074dd79e8b 581a704418ba8f49517cbec2bbe44e281c2f5042 +54ac7856186ec30cf5e419d09fc567128eb24a7e73244f70f55b4860065fe055 74766fd92581310d08c6faff6998dbf307800282 +54e3102db46f8f1304dc4ab62763a71f915e4918ce4c7dba10c015a4f807fe6a f4e43ffc62d7d238e971ecdd8617d45ddac81caf +5522689ad5f3e1754f7cc5daae217735eb70d0f68d55890333e8e7522ada298c 62da145b914438c95116b46e7ddf11ac3a56883b +553b8a974a6f8d2a8cec357147161961adc5a0ad4b9f5fca91eb383d8043a16a f9d0c1adb25cdce71cac5f01e8333f201208a781 +561439ae8748339d28a29eb0497876fc8d47cf78c515a3c989739b674ed7df01 351cfa4a4983e1f9241542a855d53d93c951fb5f +561c1a1f3786c440d90fa9d2fe5549290d95cf10881d334c11fb919d3c81b4bf 5d1e7929bb93b783b52bb144372985b8e5b9ba2c +5629b9b5e602665557c9c7c31f9b2ab72e235ecf54ce1943c344dee027db8564 a1c0728d12b170e1e643f219fab53b03cd4e1b09 +56359702cb503f029d099bd51e6c54d47b0166dd43efa99ad2d05eb548773970 933cb118437ee8a4422e956197a8a4f09fd7e9df +564017a60020eafdc626cf1a2caf4c57f128c489d23845e70e0c3c4dca8a187a 9ae72bd6780d6cd354719a1d84120e0690ffb5a7 +564d38d384f7e08bf03f021d1088837f3f4dd0c1b2c495fc3733c241e7586e19 58abd58a7f232ec3468da806682f39267d5b23bd +567e9815220b48ce3e8b3710364d499f84be5e1beafbf04e4e9d0772839e6213 72ea4e962dcc9bc157391d5679f13276a21f8c37 +56abb178ac61ea5ad9e6d2e0eb7dd731c1ae88bd15af3c65623f8d93212b48c1 630785638fdad6d35d47213ba2867a702777dcd5 +56b44edb90e571e38446121cf36270dc284556d8b5e1150ec03f9fb2f9059a58 83f7e7bb0a88634bfee2c4cf3434a2418c5f2880 +56b5280262679ad90e14567f62e22ebc108c9765f8421beb643e2ce0499671ee 95d21f5564cb13338520ecc7fc50b55866a32b24 +56b6ff774f9a813cb058c31144b98d4254329cee2d00e595fb26336be9fa9b96 b376cb120f0113294b80e7fd540d5dc197797764 +57ab87cb9eaf3afb28933d81fb2e3ca43e699cc1f02da50a56c3afef103b7673 ae31ebb7078c0bb2fe5a3dd697195e2d9068dd92 +57b1d9ea18f9cc3a9c596ecec921938223879a49c375968ea034608e077283b6 76d50675cca89a89b263f23d2014c7de7f59565f +580474d948cd2ebd2e5ce7a5b81b872d87ba4639c1ac4c0fa7a11a8eddf9827c 412ec4e4a6a7419bc1be00561fe474e54cb499fe +5818ece015b48860c7e518f12b06399b60d7868b92c3fdea05f2d25d0077e476 498bccdfec1fc223c27c0d84030ff419058e452d +582841d0c8af7a4d254d30790f1b07b3ac8f3f1c947be0a31791e84e307da00d 9de0a701bebd5d07bbae73bbdb3f8c39e204bd20 +585d35a8f1d6c41b0d48ab5722811c0daa8bb51164f24d77bb4459f95cb05169 44181c23ea6c39d51a4b481dc59ecf2cc3967e76 +587d967295661afcdb5a1a7162f59927c824268d19cb4d9b81fb5962d55b9bf2 225fe21522a98075bdc18dae90ce459f797ac366 +588e7ecc3c2704834f904a41fb90bd1091ac1eac8b5112bd60fb2382087aea82 9a827fad4fddacb757be5c6eb3e8c5f323ff9952 +58923faa87c7d559d308a114ec2b164e5d6046c889420ed1def6eef2d55106a2 785d3fe8e7db5ade2c2242fecd46c32a7f4dc59f +58c150d2dbb9c2ee86c46b5124a9508f632c1fb35325d8a8fd1c59dae3bb4b42 6dafd0566786a417cfe1131ab804b162fcc79d15 +58cbb3fd7fb9820caf0f9c15b066ab41df8de6fdf1c83d72f3bb460a9922b2d3 7b08db51663cabc4794305fe36fb5e09c575d883 +5905b697743f4998b3deeb3da29d5270ea6bb52c90d4dadff6f28f0f72edb968 2ad730b25892080b9bcc990c05079a8d605946d9 +593b262bd7c0c40d61962a36f9e9983402bf8b4b585a6245a47b161a31193807 7c3f1a8504912d590d12048d32cd31d2d75d69ac +59a1967792d9b5338bfe0bfb7658a932bd7a65b3aa8c8401dcd6f149bbe1e4ec 046c8a0d9a405b354f298c7a73e8755081a949b0 +59cc00acc478955e567e5d9eb9b888b8b538165673147538b6132b4113010171 e815adf588053e45a5f5410d44a586f69e66c1db +5a025657f0e06e135eff8536b93877c7725b74f2317b6844c002ea135797c531 425b3cd58cc77a921d6970967aafaa4391cb7f4a +5a0eac41da13655a7cfa4f4586d152049b9ef83b5cbb41c290e3529a856c7fbf 2a0665949d7f96b9776b6f36f60940351b47cdf4 +5a1fa5495a4229c962054c7a09623056643e55db9601d584db08039af54bd01b 33fb00b13d006c5497ac0152361769b650397dd6 +5a2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b 9a03079b8a8ee85a0bee58bf9be3da8b62414ed4 +5a417fc113d54074a22bcbf157923fd439fae36ef7c22cf96e6a99542809495b 200a9469e6f76a538b8539d671161a573c3ac91a +5a48249041aa1dc714d3f4337776768d827320553e118cb4d99673dceb9c975e 0ebbc36594071221b685805590415d74624f41e3 +5a4fa7cf1e417c1032786472b9906074d75df51bd0a5870b34125d3e386d5b8d 4c67e2e95f0bb6f0e214bd7bf052f914d365f129 +5a9353a7576920c090a94ebf978f786d43418c111468ae2a343eb561324dfdf3 3442b9486ece0187998e802a3e98f9c97258133f +5a9391ddc692a70f59eb4640f4f221bbdddcb4dc9ce0e8abcbbfb15ccb9a1513 beaa5abd55600b276ceba3363285fadddb906433 +5afcaa3ebee991ad963e8bc7d3d947da769dea7095973e5e6be1254138855e2b a62239680a8bbdf85cb5602325caa42abd141d66 +5b0f9a00dc1ccc48a7d52f512338cecd3f4f5b9706c227c5f8fd158419862da2 c63cb6a816126549e95c8585a65942981ff4d634 +5b264a6c0568f6e60ca657ca41b3608fca3a6ae87bd77ef9635edc75b5e421ec 6d681ba6396167845281717f4ae90389f884de48 +5b92057969cd5f96af9b9f1504b532bd3fa93b9dcd5d58c4d650c3ff640e54a2 b8d515dc02a663f0d260c69e23c6cc42a363d5d6 +5ba7253f47d390ee2c7c7afe8fd9a963a7a2674bbdadeb9a927665c9246306c4 e04529998989ba8ae3419538dd57969af819b241 +5c05f5112a30ead09ff2ff553056755dbf568c06127dccecdce9e2696fb41398 634a64b10a627e64f1a4370d085eed0be242b6ed +5c14a1005d727dc5ce74effcae1dadc76a77533167c76347e04844c290aa7ad7 4c3bbc923330f9896bf5789864212cec21a8ca0b +5c18ce500d2a3c3085f74b3e68dc4ebe703a6210b3343f50796cc15cb18c7f8e 20e7f426c3d56ba9e4b55f31a61835dd0031b464 +5c3bddffe44de776f2d7715ee97a62b190049e623d3b278ec131336f0a1cdd70 2506dae36e0f9cab6f81fdd825d808a9e4c12dd1 +5c54a41a0ef2f1b7f505d12cc7902120b6ba3ada7e023307792b56537fef2a49 e98f74e52cd1231424378d9d26ea40d1ee4d7fa2 +5c89f33a737d292d062924589b856045d9d24630fd3bd1afe5e65e53166cae89 192678b55c30d0652356a5021b521f8e205f3428 +5c8b348f9e152d98efd79d2990dbe4c702eabb06d4a1427472c1435be0a13cc9 50b20c4bd550428a6f33137bd52db4b69799f1ef +5c8bea399f78d3d6a037a41cee2e763d00024180b66f2ec738d443b6a3dd7081 fd899f45951c15c1c5f7c34b1c864e91bd6556c6 +5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 8e73b769e97678d684b809b163bebdae2911720f +5cebe9f8fc63534c919bac2f0c8695c707e33647d44792b16e28702d26e0ed4e d25d5d3bce20e400407b010132579541d116a8c2 +5d021306f157c028290dc5eef52bad4a3998b50006fcaf283cad4e6918157c6a 54b9460fee5219cb5a57118bce066697704ef3f8 +5d2460e61d9d5cb4fbdb9a017d4761827f339c067ec209c8c44529a5d9c93239 36f0f61fc8578478a9dc9b33a1a0d07cdb98a5e5 +5d2e103059f5a5629d12e4bbec2e6abd1d89f225dee891dc630f67ac331209cd 96f34447e508c58b5444992d4522d93687c9ddc9 +5d33684397a6875ee09f048a93202b5ddcc468807ff5faa382f9508833af38d8 7ca4ceed50400af7e36b25ff200a7be95f0bc61f +5d4e078cdc4960b27c7a0f8470c9d797ae21983e08efc65d0cf36583737b183d 0129895fa52dfb06cfe4f1f456d57d8e16453686 +5d7a52475763e50597142ac2dc2d1b33d771ab83f3a719fdc0e7b880bce4513a e589dde541c522ea4096a32308ee1db9bad53079 +5d809610df93ede304c638ccebbfb2aea1010020d5a04e25836320a890e40381 b20f1d8a6eba1c138a6a41206ed45ba0dfb7323e +5dbb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f 43da5ec3274dd061df152ff5e69853d562b01842 +5e0bdcfea7ab39bfe79b8e00a459a68f5b60b2b0e7600bd01c09a526734cc769 399b7d5ee364ac49da9ed64fcbcc4ce2e0badf56 +5e4e3a2f07a2d26f7ac4ae12b4157a7c6201141b08a04a296d5c3d32bfe9d4cf 5720bbffa1377642eccac7fbc34b35a4b44fae4e +5e53b0f3e603756d985e82d66a1186c2467f2c5b027a1f4baae651a5a68d1aa0 c2ef0cadc189a076b8ed0d855da1e58502210507 +5e60eccf824d865dcee2ee9ad6c947207c3649dfc0bef1cb940c6d05168ff55b 627513e78ae0c8dbcdb62e371ea674495c841aca +5e7c2a3395be2546d41331f9e310217396252fbff62f139e41493df6f47a548d f9fce2b42184f2181a5ceff90dab05f7cff12697 +5e92f55d41b34d254a0fc5e5270c7f78ba48d70743484489a2e81e0c9b420527 52f2390b4308fe51ecceecbc35a87bf6e74e9aa8 +5ecf05b5a0c0b45065f977149190b13ac8bcb18342c35cca02ad93a3e7236ee4 5213c69284b521c5a60ff677baadd36c97a5b333 +5f191eb81f39438560c516e2f091de40fe3b7e090b89b854d013caf446b0aa8e 51fcd3cac86ed8f6ec215146b79b0989d407ec48 +5f45642bfa66a6eabdfed22c7dc5fc170dbd9a4d93fad22e402b38cbbcc28444 bd0d32c74ae66ddafc9c875b391717e1bdfd6f8c +5f45a18f90f2934e7c7985d05b2b5b3584886fd057c9202f26f562d6c3080038 112998d425717bb922ce74e8f6f0f831d8dc4510 +5f53944c9390e883fcd33819062a750cbbc9b483c15b554eedd351696583d215 f85c76fe4882c7a4befdea9224fa8c01574fdfce +5f5f4cc82137a85080f6995d5fa9ed50980e07b0d68bf96c0d8c9834f8d4ae64 66a4bfac99c07b79d75c015aed8f5972f0a4a336 +5f877d011f066c0131dd3a53b96dd2f776651a96c610e7194fbc07de06d9e851 56846420552d85e7d5e8a19109594ce4e9792b7d +5f884e140db9164254a551fec3b2da3596f9404b80a9e322ea01ae3a46f45247 6c1a2d8c39d1becfee3cbc738c9a126a29f98c92 +5fd43a5fd154026f2952c2974e251c98989a7350228cf84f27c58f0925eccc50 fa33b5202315671c762ee1612d5d153c55f728ed +5fde3c5b024dee434df0642b1f2068bd65894a9fbc346e15d7bb75608f948ebf 32e41390c34dbd3f59c8cd78aa18adcc45bf57f9 +6004573477242428d7b6ee1f642da73ddc68de2218e36b8b037b068bc3de006b 0d65e1969a5c01a5ec64b6950f17f132bac18a2e +60087c8cdabb0c7a8fc1cb6134747d82f02a2a920d4c2eb7dd783e7ab1f37850 b3715dc1acad54598fea69d118c992fff7ea4ee6 +60b2cd28c2b0b58ab103d838cf2ef4522a1c42490cb93e425df77f39d7105e03 458c271d8dc57f36e3c6824d54a7a4462bd3866d +60c64d140395cf067197db3df59b33830a8ca7410c0732a1c1643dfbab2ed069 2ce6f8018fbaf125ed50e66adc46ff4f9d0a9288 +61068c6c7b2f2254e55c83317eadfd4ae210a6dd362dfdf4925e1ca20c345d17 b231ef3acdcf396dba5f83f89488be7519da551a +610894ea28aa99982aba7156a1a6ee0d18652d43f7ed7b2dfd89fe1252b9e645 93d96a8a0e09ccd1526ae4e769b5d41c239db3fb +6111c38997cbd2dffd851ad4d840c9dc45bf992d342b827bab5114ff519ab57b 1a2e9c0f19f0143c69fa2c4d5d95da3d5ccf1357 +6129f1672465ee7b9e2edef53fbf3846ab5d06e8e6a1d7fb51e31666a8b411f8 b0941f9c70ffe67f0387a827b338e64ecf3190f0 +613faf6e366095154ba6b9cefa47d7c3a664401174497daeba14a13c3e444fc7 77e9dca7958f1ef5a01dd17de6e5fd1175a13ec6 +61489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e 1810dff58d8a660512d4832e740f692884338ccd +6152d01aacb9fd63bdb908a5153ec9319bc837b50a22322aed77ac01764364c2 32d6b9111a767ee0a7500f132f797280dd042367 +617e5bac096ddc00f0c17e6dcd6a084cd21ae6d4ef7369ba888060f3c7e0a988 2917c22c87060a43fedc431c0a125cb15c1e3bc2 +61894490bc16340ae5eabaddab9816b93d2231629f5c5709f0c09d4c9dccee4c c985f0cf48b852798f4c5752da322a34f6d386c0 +619f24a7f37f8ca922c83b3a1b9a384eb6a444ff3a2a52c712f3c60dde6f24fb af55d0cdeb280af2db8697e5afa506e081012719 +61d09b305f785a367a8e1cb85347dc38d4ae9de484dd3f2a5bffcb1af3b2417a 803a6b4d418c4b2d7463bf23a86a09cb2359ec98 +61decb10e8bcf036b7b0668b5f1e158381a26ad14f4420bff686801f9824aee4 1f8435d47ad5fcd9e92a80d1cb2b8836fb711366 +6257fc48e458a95396b6781a738dbae7866999cddfccef63eb16f0919bc2cb82 4d25aed8f9ae7653206031efdb0b682d62ece767 +627d6943fa03029b8c4d730ab2acd266509261d14042b1445c477505b29fee21 3ae3c85110b04ee92aa528c3da0956391e038cf7 +629e9c4fa5465689d98c29fe048a1aa7f52da0235c5d67842322cf5d183e1175 b72ca26740c71371258bd178188a3d981e39701e +62b1222084376703ecc7737181def068375c47640206721dc4674491b8980a5f cd874895197adf33e41cb14cc4b5fa2fe7ff758f +62b4aed734e93df5fa848ee90fcc38fa472e13581d05fa42f11f6aa8a388da89 4a143abf80a82b6e51a3a32e0be40b4e559f6a17 +62cc32311fb4f113536d2004edf25611cacaf657bc1f59552032c7cae29cfd6c 65912dec2c33ed1cbae320dfe24f868e10f30ee1 +62f462260b2bf90079c917b3ad2cbe8eb2c8bc136512961c839ac53845f7bdce 784b10b4b075a60fa18c703b88a744a30fa7eb3b +63071afc7376250fef5787562b2463404ff4002698f92a61a774bda0a21a6ff8 22b3e83e3cdca53a20808202a795c73fb47880d9 +631b70c3c1335f8aec14d98eea4a36890c3a00bb2367761e8f7d1e209baf74d4 1b858839e1f08792f2e5e1165bb4fcffcc95fa86 +63fee1d7ec8c84e8854fe394dcd134a633d8f3de7c6a5749b7c12cb26b8912cc 99228417f71549fc6392a359d59d33050c055733 +6408a234856eb88bf60ecf977da417e65d38cca482547247a143aff624e66872 7ce66fdc1f7778999b3b3b87608771eb2f5c124e +643cb3995f617257573a639e4b8639b46bd96335f61bf6d98ee3706397c75544 47ee6e20700957518dc21886f769ef415a592568 +646b7e4bee30efd073aa27ddca866ae7ff72bb284b035acf721306ac5dab00c0 56f77b95f87e01b56f732417c1d557f0b6dc0be9 +64887aae9bb21a35ea8a484354297a8a079b3bc20d11d253b71afc1ec36b1f74 0269c3f82d4a93b859ff58582b7c6f1843dbbbcc +64dab4ad3eb854bcf575c7d9c9e9673021ba74203147d130a209ec2f04a98715 850cf44e8347194a57fd1fb637f0a12f1838ad38 +64f0605de2dcad18e95b1cbf6cbb85064f916406f63e8f76c9c223a4e59d1e55 eee3d3f684fda02fc8614dc4ea5c399ee71e7e4f +650f6cd874aaa3fcfbfdaf49d6683dd6a3e9e3e45d21987dcd6d67d11bd12632 7cd60e59edbd298d5e2790e2e62aa5c4dd55e8a7 +652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b 6dcf9bf7541ee10456529833502442f385010c3d +653aedbf79f7c6e9377832bb81f3d408988d1ef51e130b08c29217a9a53daeec 4a59d93f4f618c2b2ede1b21c807cab24453056f +656dac701c40a400c97a4d145190117d6f226b41ac39801032b5ce2f8a67881d db31e1df61d8586c1992036ce4585a69fa82076c +659c01981f8ecb286bf26d7759cdf0e59f3250dbad69c5d74e38c5ca5c8ebd36 c1052be270f379ac8e245838c8362f89528c8e34 +65caa3413382890c53fa78aec55069027f1918985bf6e62c97716cb846b74f0f 0b59a10d29ac9446320f6b9424e427ca7548af77 +65e0543438a38463238bf25be5064d5e6a9a9b80f0d67c3babe8bac7a3f9b269 edf57b4b98fe7845c0f37b6d261f15eaa6a27556 +662c71991cb89a89f8b0d3479839daa1c3837455808983dcaa3c89131757d4dd 408de023c9bae4e7cbfdbf7ea65f0e41012f5a4c +663848827efd772f21ab7953f2c3edfcca12400bccf92de5616e9ef57aa09897 7ab2d5413945768710d357e69ebe6ea89d0e0f75 +663ba0d9c53f18f52af699fcc1f7e1600098961324a48f3e264b98718e189498 c9c7b0e147c44682c9d4a100dce290c14762ff85 +6675306226a1869a0e696a57ae9f8172511d961199a2ec17ae6827e39e4304c3 52e47ee702754a385a930079d5e127486e52bf68 +66a993bb9ea76040f448de0e3bd65d1f9d88dd5192921cbf12f234c813466452 75e1e84d121120833cdaefc7e764878b7cd7d602 +66c5b943797fa9a7bfe9194d4f1550a9c4ad05d69c6d1a1be4e97932cf06a813 4c9a39732942f763191d47be51b414bbc81bbbfd +66f3606b5eb16bb5a34fcea47edad9a68a54c2804c09da37afbed6bf512d5221 ac8237e18da19ff375f051a973bac91d6dbb2f56 +66f736d33cf07582c5d6366a9a1bc39d39937714e729dba38a7b61faf2b156b8 67b430937482d4d1d877ed3bc4a6ee743028c3ff +66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb 41bc8c69075bbdb46c5c6f0566cc8cc5b46e8bd9 +670332674a169ca0bb0f1d14bda945c03bd6687b756b4a54bd8da9208403fd07 5e9e1f22cc64d3a31b37e3d0c865228a71c4415f +6705ab009e12496e243d5fae60f7ce6c77fe68325a8818ec75ff317ae80c5e78 eba91472284330a048142950c1de90afbbbe2c0a +6727e691fc664f1f28bb23cc30d6b84c34382029e56edb264b2498117398f8fa eaa63e1496702ae9c36436969edddcf7e9817545 +673e079162dc9e99a8bc43698e05492357041a3a661b104d1d40fb37e89cf965 dab2ff4ba3ebf8cb58f5b52975a58c308b2ed283 +678d331b936a897f3ada21a29b403968b075611588c9b176abf5a05d415e275e c8d42b9bd1b6e45f48feadb5b02e152c5e5f1f62 +683b60d7962844415b532765aa212699c5414b0833974f292c233c6c8c380dda f2b93d4124d2a46ec7070cf6a40a3863e2c15556 +684b9226d707a7b783f0705986600b2c9c7decfbc9cc72938cedd113a8f0dc83 7e44c57fbdc0eefa79348d25870369b2f4b43ed0 +68a467e533bb9e4b2c5ad712d0f8d1b484bab740dd667814f1c9cac3a4a30fc8 19af3949ca8ce2831049a4755bce3091d7f4bceb +69136323b1d7ba81e8cad8626dd83cba0c41f780caa43421f0e5f2462d78acf6 cb3ab00e68da089aecd496ba4e39b1c706ed7c68 +695bdb545f636d454b4825effd29db96c46d81772dda6c104f97dffe2ec509f1 4e8cda27ddc8be7db875ceb0f360c37734724c6d +696503760a18787240ba52ad1abec3be6517bb802238e9469b3a8999cbd6432c c07204a1897aeeaa3c248d29dbfa9b033baf9755 +69c1a2bb3151164052ca0435160424d460eb6268858cbd027cc551a174a52785 5fdc7166eac68b0b0923439b8685a29ff4c2be27 +6a23c1c1d0570cfa36151e678751e16ae587b0a8c262efd011a4716555b345e2 4d503f884a241c507ec4e474e3e3463c2e394d52 +6a28b5afbed89366932ea57b68cdc739f347d242f0d6e6a0f8e9a794205a5213 11fd982b055012bc932fe17b6187629555000b76 +6a3ddbe9560f1509d2a15cf4f580ece49e83b83f9baecbc0f5ea512ee93e63aa e35ef00595a0767f16bbae5182f7dd1c07138834 +6a44891d48bbbe85ec77c332a4d809ed1d7bdd39be781785d7e8b4b31a97f586 963f3cc863ffc5d238de5ac3f425df6ef1e3e3ea +6a4f8e777996a56c3d69559f2006bc0f0a990130aee3d2b29aa29fb3cf7fc437 1b1e2deb5f90be7f267af8d3d335bb47d648944e +6a5f397f63599bff44400a30cf482d44d5b76808fd9b24c043e8da3909b7971d 85a843cc1363932d8cd5d1e88024b9357f0d5572 +6a837864fb44516a249c5df72b8674fb3f16107af84e2f38c9c4f2ae7bf8676a 357bf823711de56d93f51d9f4618ec2068d2244f +6aaf452708cf86455c8ebef269c0cbcbf873993e9cf003e3eaae8569eb997da8 a1a73455eb3d2a9571208c4d4af74f4ec1b1d161 +6aee1b075ec6d9f63ec6ff0689e80f4df81dbd2c0c2bb17a8627d7f0602345fd ec6a1926d4465e61364a7a8450e8f4c86ed841f0 +6c04b20ecceba56f5ef3dff0d5b93a551d0c6b56311599a3633ef16c3f2604aa 0051f09759ad432aefbacba58fd306dba4a13f79 +6c14ae62c1369df64a8feb0dc01acc99445e13708726f5687343ca15185a3e9c 86dcfa927930bc90239e647cfaad5c7706b9f609 +6c18ed11d243aac62a14a6863430458296354e445f0ac7927d5231161ad90033 c945829d434378a0bd235640ce08144ec35a8cb3 +6c3b3ad04c2ed7bb11f59cc76d0a980cc087bc6b0b27d96d395af4ead3950200 e272b10388ebc4b7ed9fe2b42dd46e367193c218 +6ca4b09e9c92f8cfcddf218cfb39cd76062c88e0ddb2fa387bce031b902247cc 0a902f96c80acaf50a534832e1892cdc99ac6d31 +6cc829640a9596f33442bdd65ce68aa387caa63b8b0ca914a3af4b8143ead15e 8a6be5524f20162044c8e48a530abdabefefc083 +6d0df366aa3aa46ebc26fd4099838660b562e9d140ced9631fc091bdd5f72b32 3ba86b2be1383df8e6ac574538dba7d1d5d0120f +6d159afbb9fc4660e17efcb7a3a0e1944cfec34d8f8b7d1794faa8507e5d42d0 19190397b94cd8b56e6cecbcbb4ed24c3d454d77 +6d16425f59d59f573f029a4128206020fb89e849280d0ef894b8cbfe38803af6 c994bb473428299c9d568c99805ff1b49949aef2 +6d429bf11e88cdcde78b43bd5227e273911cfbe30b8f56aa170ea00227811ba9 82b1db3b35e34c87862172bf3f4705c4aca8cc98 +6d47966640b12cf618c9bac61c60c2cc245ec18723ed4056fcb5e771e313b8d5 09cc79a662b98af20006f2601826d8fd6085a37b +6d5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 fa49b077972391ad58037050f2a75f74e3671e92 +6daeb00c6942fb4696f08232d22ca0dfa56d416450633b39cf491a18c6e2ef76 e8beee4c04ff7775b7180a7675acbe95d5af64f1 +6e22fb1278de7b49fe6b298192ffcbc3a2b1e8abcde77b9cb2ff67f3faacf3ed d9eea640862b43efa179924882eec554fcbce684 +6e490b63a52e4f2327be88b4b91812a05e62cb2500f8dcbaee56563803b47fa3 241514f3af6dd20d6d647db9ed37a6dc21d9532a +6e657f9f175e434bad449932ac6211bbb129f4df1c9502f4ecce7a5cc1fb5fd6 2525ae8a3e074a4c65659ffaad29315fdeffb698 +6e6f43fbb89dcd1526fc897e2a42008f8af30ed890af079de9961befe36ed36b 1699efc4217d925c50abee60d196d9f6e738a72e +6eab2abd4d5c1d1ffe7e473b3c8b2889bc8801457737f43255166f3ade399992 f68f0b1b936c397976127b08400c6e30c07cdfc8 +6ef8ae778c5f998b9beae6b2da18a6ea674b268a249c3b55fec38d1b8cadfaa4 9475785cffaf1ab6216a9a5f1e1b4daeee718657 +6f0055a8c0d2d3b66d21dbc546e605d7097533d949fdd85f08c5874c01ef1723 ce022069960b6347b20ee2f90681ffe7802d953f +6f11d93bfb269ee8c7a506178f60c430abfac5d424acfd9c0b0b27b98e6ab49b aefe66d192771201e369fde830530f4475beec30 +6f26102d332afdc855dd129b9486952f8c6b7c071fd96a6f1f762c95a79a3d67 064301cc3528ec3bccd07dafe9af824d87a50dba +6f3876830557f53900630d24eb67e39e64f116501ee781f18d5d3c1c823f255c eb815f96b04732b893bc17c209665b211e3cab0f +6f6ea36739eba39758b45f4a0b0e7ac3d5c3facb390751101e2a8998c3a6f190 0f39781c25a06c1d38877adef4ff5a6a5f67f1ca +6f7d74e7c76bad67c52697562414ac40cce152a6197b3621342f4009c141ca4e 556c36fd15024aa7e888c3739d74dadedc6ed424 +6fae137ba81d0d81c2a85759b99322e7ea8103bd7c8b85be3163b7e91e18c125 cfe96f31dfad7bab49977aa1df7302f7fafcb025 +702a6340ce839f0cd2601cf6fee0e4bb5b308fc8c0a731aee40d1bd1b0ed5f6d 4498654c7989a59db451179ed264ac43d3b7131f +7030f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 814889a078c031f61ed08ab5fa863aea9314344d +7039e3408aab6a7cd4c16bc8ae9fa81407ac415c427466a602bee592d3ebb243 0238a56890c6185070331056033f4dfe61a275f7 +70bc69623357648bb7ce7526e92d8abea0299a9273b9fd28fe5f9ad55048445c 73dcf2876fecab9adba9ec9bc148ccbab431af12 +70c467f2c60c4c2b12e0a8343c454edcb457bb7daee059b6f7f625db44827ded 12a30e261b490439ded615bddd7d6e3a135fcd13 +70db96a9031877b2d11791f4a75ee2e2db4c6c657c9f1d5e30975e69108ee95d 4078e70ce62371860584b6f42312097b1fae94f8 +70e04bc26c957ee1d57dbd0ff0dc8d8086ebad49e3dd4fbc7b158b544eba4b21 c20cadb993d1ade2db86def0b3e107765d2ab3ee +712b2b96ef712f696523967fc471a5c5d446dbefd9bd46853e6f3030fc4e42df d1ea30c399629de48ac3fe68869a21171ad131eb +7151491618209e86b24c84d0bf4962828c4b1ece1924a44ee1d3cec82d0c7ef1 8b6f008edad28fec6e3732fce75c20b0608e4c46 +715588dc06122ab123e11c9590ef6fadb817b103da857e89d619f98381e194fb 33458aee86009abe87f4f182120e0a01dd828ed1 +715ac0c5f0e08622ce2dba0358e6180103dc26aaad65f463fe319ea28227c991 7ce510638eb4f25e6d74a788e941e27557831291 +716e598151cf540036a73177dbf04dff847cc5f0123027bad6111a2b747d6403 4b44ce23b4357ded8bdbdac545ef49a39d5bd6ea +71fb49e1a6feda729eacebd50518cd5e0dac988101fff035bd27e66a2d1c020b 54b5223aaa8e0c973ad508f4741e2a96961c0f3f +727a5310c154efc27b636efe2503aa36928392b543a121fd4c67e991e53be3e7 efdf2bd1d646b85961828b897633374b09249fcd +72b2b1341efde56221a00b934ea70e0e0bac428cf3853f7f0432371cfb2694be 744e1c78fbfc9438ed8c947aa87beb000fe4bab9 +72c472319cf7d5d59bf9fea9e90b9785d7ab39340003fbc68619c11a9e583c2f 2f205b20fc16423c42b3ba51b2ea78d7b9ff3578 +72e5af4874e5dfd926179a7df9b22f5c784d0953c08f52f57b74ea4c429bcdad 3e337843bf57f0fd5b29d56e8678d23bedb78b49 +7348a064c19fb5f536cf9df91b0241da4dc493b2e4eac9b886b7de3f96b0c414 ca4bb51f66396b06853c444a1f3d259267a7bafa +7350dbb12c8f696a5c1f758da310e02cbca318c96c7854e13ed9383a313c4a09 3c6a4c09f57517d0670e5e1d78587c643afb7d80 +737b6922276ec4b8ff150f102403c48c4ec60e6b3d4ff6904261bbe2ba2d61d0 552e23ba566d975b4dd48163b91021892504f021 +738ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed fd4959ce7510db09d4d8217fa2d1780413e05a09 +73a5d42076f213bc0ec6816f8a51e3786d5fb0eedb6d672b9793d582eec8477f a7c60cfc6d3af29669ef5cba9df325719b9f30cf +73b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 fd093bff70906175335656e6ce6ae05783708765 +73de6bd126ba92253a3968a1081da3bb585f9010339fa8b9c02ab1c37f253bcb 6522d02a70408e526425ca1579215bcb6bc505a7 +73e67e592fa176648ad7fe7a65c8e3e782902ed1e6a2a03b2fdda1ce0648d705 0db888dbd4366d6fb2e5871a6bba39530e3bca70 +740441a445c2ab20d2ba91f9237116e39c25aacb7527bff9252a15a376ccf1cc ebd94df2050b09575346ce82a94079dba504f057 +7436189d4ef74b65e205d88fbe33f8b130e907b7951f03e12366ed6124342aab 88c3c7230f3d49807323df8f01546b8a7fdce9fc +7453e1303e8cc0bc8fa0debfa7545e7f6b8b0036ffaf950c1d86f86710ca3bcc 562c86cad456bc709af6982e24256844661fa5c1 +74a75a34793adfc5dc91b0997b113e820f1a08ce3f2582580b21a63a22db2dce 977c1793305b307275e2a12335b22346efb342af +74b69ca7e493351440a95d92487789420cadf3ced93cc3c4f9451e4483d7a1b4 1c2df27a59b90ce934bee51a95ba617efce1c77a +74e28415489b8056cb9537fc207015aea0e828fafaacc5bccdc93b2f1609e479 be01c47996d638f76c9149a90a25939f624b6cb9 +7509f5f98d13f7a093342e712ea0876cf17e747f8e2d04738d8592401da74586 32a550a0213bc2254d0e46285d7df4e154573009 +753ddabab8ae9c1e733cda15e8e3c83dd43f5a2d939ae32cc3b30b0be1e91f96 4d8d0fd9cb6045075385701c3f933ec13345e9c4 +755b0be6d86fcd39eb376f2324bc61103ad7268463b6eef46314e079a4d2c34b db31c0661cd0bb4fc5104aa0f27b1986ffbf9214 +757f587c2ab935eefe8ac8e05e3ca862e9bb838cd525a6c4402839f532713b5e 360b107978af0651ca59f07430fd71ed52150e4a +75b0ed5f4a2d5c810f34d867dbca51db6a596d4739abfaf24fcc0f05d99097a8 10b759e734e8299aa0dca08be935d95d886127b6 +75d6f2e4eba19cf2adaab6f58e16c9e3eecce4909efc53d6690f865a4f89b53a ce524c6b3a984455f474968d01ef86156e92db15 +7609c608c1097270356a6fe336a8756ff124d4a9c2e941bba26a6e8c3becdeb1 2ef4e5d838b6507bd61d457cf6466662b791c5c0 +762099bfceec4cf75e4f0cf913c7ac6a0ba6754249fb45579f7d820466045d26 933888647a5d500b90c472b5c99fadd6b8691c86 +7655c1e83698d9a5d2fa841438e1a0ec815d7daddbc7a21a7e930587c880a2e2 0817229bc1a1fd88bfdf4f35e2ca11172054756e +7671193d6cd77b8b81681438be0bf15db49ef9b60f5389ee74b907d7254f403a 5069c192113c59f791d5f566c0a57f6714bb856a +76c1bc10fdf66c17d7f9c02a12c80cda9d1f14fcf9a467e85160993f807abfa5 7cc26c12adbe5ab35986e2e57a572145c86bbc05 +76d5d21efad0c83f17a63c2a68ebd39136b56fc25f97e0697ccc6c73973c9753 81aba2b4fc907644c29735ebcceffa4ce01dd23a +774fc4ddd5efeac3ba9d525a968612df8097a9c903ba0b5b33625ca86eece2b0 9a4973ba6bf406aafc48b98677422fe6e54cf764 +775a1415621a751174ecc0bd86be251ae64c305f39c0b6423f8bb5a2c4cace70 60811b0baebdec5b8663134d8b754b912039b6c4 +7771d48bc8502e2b23c5f87c5f82b446f90060d54a8094d4dd829da9cb5d716e b3178627077e4c6b240ed61c4e9a3f80e42d6c21 +778c14d7c53286273b58bbaf5f42aa7ce8bff5c63737cb1b5d3dd99fe43fa32a 46a29b40df56c1885fcc16a59a95bf319048fcdf +77b15f8f906ba92609d8e70d038973964661a30ae5a1b9ab52f96dee694459b1 0ba17ded678e92f9150df14c2e9a310ff5a79baa +78247330cfbfe12044d4a85428ab774b9a88413b618ed91d812cbdb1694be9eb 7e7c39379436c6c048670386fd4d470444232e30 +784989941709ad0a0f4a6e7c9065f081561dd146e7c84a535a38b8c2b89389e0 84b9cec72cc98dea3353325e42ef78b3f7e7c79e +78568215f27ed3fe1e34ab5c944349511304e3f2b9721610599b3fe24ef90f60 42c07750c431b6bd77c6a9e1ff4997285932e352 +786ea2ae3bc3abb0f17a985bd588c7e95934a332b0ff095ded0e2192e29d42c1 938317c9319e3280b38d705ad1cf74830cb39eff +78ec10765ac8bd54fb141ff1601aa5fce9abe86141d2b5457c0a3dcad48dbc61 166bd0fc25eac4f184a3185eb5994988cfd6c201 +790bf70318c215c3fd3d8bbf2c6aa799f7a9407409aaa79a6f286940dff143fb c96d985df9957e7c042290d868d44feed8a4fc08 +790f39b54161d26f82f98c7ebf3620b0fb7763fce49a5d2d1f6213671c2b1bae 8be50a412d448035b974312389e9a6703e71e8cb +79239b015d62fe6c9c543e6f394372f63ac181b2219bf7eb451d397836377890 d48d51dea1dd8e90bb8c960e68afe72cabc5f6aa +7941b4226958aa66c7f44e76550ed49408f8665dd32d823fc6c59eaa16ab8f02 6e2b3105c1c5fa82ae4e33a8c24d50d69c50782c +795db8a78b6836d82b72af2904b6df4587356b800c06e74159d39b83f2ca76db ebe2b33d7c2366205d44620e57da3b0afde2524f +7989c0a71ef11028135720da34e14d29e795c8e78e450cd85a49d0bc7913a8b1 1a7bae4d0f9d9314b905109b5b321219b7e6be3b +79bc735b91f8dfa9379d1d6c21e2d519ac1bf0d04d48534864c9ff571df5297d e0637ddfbea67c8d7f557c709e095af8906e9176 +7a07cb0fae32a92c8faaa8f6aebee30b9e10b25e1d4f49726d28f223f4bd5255 c34eacedfaf132a6f506d2125588a9094eb82812 +7a135043f1708123027e529d2fc8102581d11dcc2dc51e32913014ead7132ddb 065d464e42f271efe08daf3f5b69dbe266266880 +7a1ae05e508530aed4f9bed33082bd4191feb167f2d351fa27180970fa375b09 b3be0fc7562d51df415c14abf671deb37d8f89ef +7a1d4d9971f84fc5afe7f66d5925e78e67a8ea58e5569a519c40f671f44d0b8f fc3ab91bb4df267ae9de1f7b4ab596406485cffe +7a5d59089d4a3dc1b9df7f4259be2ec0cf9f9819397b775d53a6592d62c471ff 4c65453197fd21460f0ddf2b722ec2fed6af221f +7a7d3b7a1c17103608948e990a24f4a67f6728b7c8a5dbb3f369e55972a55d4c 73c4dd9253f8d43c436fc88e64096910f4f1b8ee +7a907433347ef815623322907d4cc216939ba2c065306fa81b2fbbd49ac42789 4852017de90aab7f3f2af89ce8ce29fe8226af34 +7ac8c1830b6a44dfa1a41203f9368e79de094e5b62134bc3783069ca70080cd8 0acd9f8ba026c0e6845ca4cdb920cd27503752dc +7b0d0dfa23c212f76f2317ba39d30710ab0014c9ac4bad0f5ae54ece22cba249 04dfbd14950661cefcaae35a7ee273c8775d1bf2 +7b5110bda6ac70764dc1801b16e91b662364cbeb80884b3f6a0ab3e4c4028ba7 f7c4cf4a40255c3b0ca8d8981121e329478a92dd +7b5359b4e59ca2f60b3c528c5effabb858b81b1a9b5cbdbf70977379230f8f5e 2da4231d050f9761ba615b77fae3ad00a7d479a3 +7b761468247f90725be8d05d9744bea962f660617685c76bf7b2c58fb125dfd2 b55dd77ea78ddd49d9ee082e2785b3c1ad9de7d5 +7b9d5e67db60bd61f55eeed5ba200583330d36ff4ecb53a6c341c2a6eb3f681a 4063e6c4aa51155f18adbc2bcda3d0ee63880c2e +7b9d61429850c13d9e3f280d37d51b2e0e3873495d610f371ab45807cf0b3bd3 e8a952561c4e59ca308d1973de46fc32ad91a022 +7bcb94b54e168e6e26a3cb840139c11c0ae7634203e8a614c3caf1eafcef5fcd 792a1db7cf2e1cdddaee0446a8cab4bf0bf2f6fb +7bddd447d756b99d30b72a45986b2324e161a728cd3af6d44a089656395b60d0 d23f6863f89e23c82bf14b91de931cb446294af6 +7c0d59b28a150c519159ac4562b1a4dbc1348bc3caedf70af29584fe226988fc 431007a7fb7a938d3061cfbbb438ddc42ae95c8d +7c2ef1ea335fde84cc76d1a10e4d4012c1f5238e170499606509ad3c4530ab39 ae23486285f4e16896afd53b20dd11180d26381a +7c41edf4209d1b0b0e793a714e78107e7322d7f473fcef602d52aa5664bb5735 367ab010d69ec4fff533c770eba5b1882f79cb41 +7c50daf12d9002ad995f31e02d6dbf7851a586bba49118d87f69fa8ee71ff890 9e90ed0d151be3fe089cbabe216980e2f00ab242 +7c73285498380b4af00105c8d1f887472d50fe26cfd3acc2dab9725a716f3efa 6d091399f96a97ba9bf5f3d82b43179c82a93312 +7c79b5d0b74a35d095bd72c42c8855851df2a6f2b07e926259a819306ed7a657 a1a5bf7f5e8c069ac59fab62d2f7a9aedf198413 +7ca86b4b5f7fa4d66a6dd5715334af377f3627977caa9d68a3472a6e7c3433bc f971ce419affdcf8545527ed3e55e6310ab8731f +7d31d02993384dd0237937ba6ca89cc504fff2d366aba10bb81110a82f4de656 2cb057eeac11a10cd4864a66d8cf4b5210bbe308 +7d3909567be3abdfc8a087e14457d7238887602385f1700ef81ad5d65f47d130 47fd30c3508b95c97bc9177a59fd0e2d0a034277 +7d3b8d28c951267a7fa4c1c75dc171d8f0bb826b9b919bfbad2aa6d181a53a52 ac3e84651504dfc63c144d35e6802a111fc7d75e +7d41257ee4425e8a204c6d6a4ab54f46f3a370a01dcb5d5abcf54060f411c944 ab9e1881cb3b612e775f1ba27f22dad911fd0cc5 +7d991a5ee9468d8278d9d790567db72ca7c907b7397136758e18c267e39ead17 caa749d19261a3d284833bad6d8344bf33ba6e7a +7da15ff8e29e2eac38e6f4fac5611f4c4a396ac483e0be7cae06c9186d2808b7 f5e3dd78875f51a20d22e4bbe3adbbaa20974387 +7da21d9aac71e4797714dcc6ca3350b265f7e144e43715e9f39a401c4bc96816 767f20ca88fcb1617bedd49d413884875befc79b +7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f 8496071c1b46c854b31185ea97743be6a8774479 +7e6e4b147775fef8d337da248ecaedb10ed1f00cd308c85cd142055b5ed414e6 78abdb650f92cb34a78cd9ff17a013f383dac0f9 +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c 258f0e2a959a364e40ed6603d5d44fbb24765b10 +7e9a1ff18073a5033098583da250301e2f813fb87a718e66b6c21e6b9d78b8c1 960678d19dd854cb3d5f1d234959a680bb8656ed +7f14ad6df05c4b6444d964a5b963c3c753e8ea8a6d4b2f51819a90b841f788cc 7dd8a9f71052cc12f8dd9c1eec2e99afbf08df76 +7f1c021c028dbba42ebf0688415150e8d9eebb1470b5b23ad41f9b4bc5149406 6267cbc52698d2158581d2d63a4667ada2d1df22 +7f1ff49eb6a35b7a50e8e1054e0690127b6fcb866cc2c32283a0b595c39a3a42 0e6e7fdcbf9cf558f09a1e2b1d9ae76b4209ccf0 +7f2d965918db64ad856f1b565281d55dc401d04493a57079b85724ebf834b6a7 b51eb250ed0cbda59d3108d04569fab9413909fd +7f2f7afccb317bb3fdd28555f126846dc4eebe5d9ae7b8d8a1456e8ff85422ce d76d8a6390d1cf32138d98a91b1eb7e0275a12f5 +7fa1afc6ba5045aa7a04b5c88edb03a13ad98702fe1a98f7effaf0a128a83ec9 8669fbeeb6d19f564281bd064a21a31206bd18d2 +7fc47fb594ba964d7397406b5a2ea930a40e870652c0ce3a30c16797d537bb79 eb9264e3ac14439f2036d9e47d31f6f94f073187 +807dc79b9af571de3b9c82133b77e38f81eb8ebc766bcaf2b2b2c7fd58feee7e d9903730e055e85e16e62356b11ba755093e72b0 +807faa3586b7f1aff2797a7c39c135b0196647c9ae7ee8843322accc960b2f22 6faad60901e36538634f0d8b8ff3f21f83503c71 +8091b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 1b8cbad43e867676df601306689fe7c3def5e689 +80c5983f528a83fb288b30f073e52614f1530e85904c71974a5343fc4b16a40a 8030223178f0bc0ba83a453e0b7d1585de4adc9d +80ec1e36b983e68664e8357c538cd35b30638bb0cb99626f906d145e2d2e2558 fc3c3a2083e9f6f89e6bd53e9420e70d1e357c9b +80f961fefc9978d410b73aecb091bc67e255e94f7e7c601f8a6addad6866b290 13de54b9267a98310d25bc6cb06caf569b2bc26d +80fe2c1b41caeccb5aef5b42580afcb065b928c4f95a1094d46b9ca1e3702428 f3d6802e942425bc120b6971e3bd8545059eb063 +81274306bb28af9ffe7c212be4e48209b9e13f2c82ab3821bd402b175a10851a 72b9511ad87afa7591ea80101da12f8c17bef161 +812be9eef0a2edf14229e1d392ca8d4957eaa2e45c8d3949b90dc3aea7950648 0fcfda73c48cc5cbdc6b0a328b9fdd7f2ed43837 +814681285f754a19aa21096d18507b24910a4eccca24cfc30918e830f6de83f6 83131fe4c37bbc26706764ee63732315906beb89 +8155958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf f60079018b664e4e79329a7ef9559c8d9e0378d1 +81a810b2374dd6ddede7ca2b3daf3cf470b54b7e9290d280c6d7e4e92f076247 3e9360aff20efa836e3592d1c017edaf881b936d +81b4939f4b31e1107a389c4964f1a987098da179f9c574cf7e5449a4e50f537c d3231f4399eb8a1887fb901798d5ba4abc02df4d +81ba4e67aa59ccb078e3dc9ff3075f50084ec1696bd867e8e4284fcfc34fe3cf 2ef4faa0f82efa00eeac6cae9e8b2abccc8566ee +81c13819eb19176803f7052925538cd08f8d0e3036dcb6caba2e27f862dabe9d 0c68adb5d31b9605bd13b92ac56a3ca6c76e8ee7 +822761cc7e699abcf0acadbf1c7717045de822f5373bb9bcec7c56cfe35e2c60 b9de2100b3991e6ed3252d4b240eb84b87e0aa0a +82462a4bf3fd4d0de14197547370d4708ffeb5c3bd75236ef485d67fcf04ef6a f34fd002b826e94e60ed67347ffbedd93793fb0c +8259bf4baab8beb19e2e194f36fb573863dab4cf1898f9c3be52efb0620137fd b433410c8d0c3f8345621e9b7f1603656972c5cc +825ca0a496df92f4a70387d4e605a509d083b4f990830ababe6062e70592373d 68b3dbceec6248d67e7bd8b3065fd8d5ff417c22 +826057e0780d68f304f3a202e8444b7283d92c1394c75866249e67f312fbe4ef 0a6dcaf4b0c72cb913e860eb634535704233ba66 +8265075eadf051a5d5ba5eb3d620ad0a859693239c82128869450a057638ae9e 49306beee0b66c81741bee1e004706b7e5c9921b +827595cea6baed7b3a76e99c658c2efe68f41efd0b9c71e76c39849e0f11f4c4 06d6e03af9a9bcfd3c97687f1afde4516bdeec57 +827fdde8c1c0714a38efeaa0325f252745eedaaa32837a45bf68e0d58354571c 195d1f67da1749b0a8d39adc087c5cc196238b59 +829deacf4c5316eb399ee7ed590a2d51192977c8ff901b8143384dc649be1e22 56931d1ab4de660b27c56ce488245e78f8c713c3 +833ecfb032c26b1a04cd46875e99367a6162e1720c81ee410ce504d7f6aa7eed 255a0dabb28beb56096af18dc20187deca4a545c +835a70ea81f05845bae544217f94ccb867c80850d363f7a237df4e3242bc96c9 4a65039859952e2ffe776d2e1afbe0c7ea02d14c +836c31befd72ff44f39e142cad83023dfcd5d58816cee2aca9740b4566150c46 ca52813342a2d2cc406c3173f6b6d65a752fb783 +838057f426dadbb890b29a79f70d68f566b8c1d19d1d954036e0d95a681d2a28 8c57e3ed53bfd1cb5f5d907a171a86140be37e06 +83b17ae4b422cbf5002107b436fb2e5ca0fa6c3d0ec1838ddeca4362bec37624 25263fda46ebc849617f65306ce5c626f5575340 +83b6edb74bd99f1b5042e0ecc2403959f19e61674663c245e76084ace8db9a9b 640fbbfd48119f1c4217e81c644b28e31362e269 +83b9e2440ea84e5e467bcf921ebd6fda90c09a1d781e8976b1550e3b0302969a 0dac883d02d2cd142a85f44f642afad79853e982 +84005e38a65f4115d5c94790010dc57e1a3297f4aa89744f5927f208af758bd0 10aa3fa72afab7ee31e116ae06442fe0f7b79df2 +84503271d3c088446000ba59060bdd4ac4119f6a7cc021cbaae918e86f220c17 9979e66b2e87b085ea23db0b4839b52e09639d55 +848b4725950462479038f34889436ddad0d3842332417707821571cb0627a31b 760529d873e72200ecd6cf05179fa0573ce77fe1 +848e2e89858bf76ddc3208ce52d8a6633d0b9c86e74b9d447fa0aff3911666d0 5a6fa6e57189ab9577c62bcb4fefa2b80cc16730 +84cfd6056673cb703ce9fc11316be0f4e9bd58b0c69af563ec8fd8b36a105847 37e46f4918c08ff7af7145dc364481a316b34c44 +850a21529a706f522be5a979f4b2dc685755658d9bb42c9c929673a99cbb09ca 6baba0d067c8ce4f23a148cb1b7a256e6fbd76b3 +85513265e2670ddd1ee23214af654254e62ac330883340cc73f1329014e53c48 b7c891c629d298f2d82310d8ced2ee2e48084213 +8553f7236da96bd44bc84c4281b4b3c059510a908ea6a4bdb06ee01bfe39a4c4 d7f80d5fb81b7f1ca8443a2298bdc07eb3a144d6 +8559f031d21ea80c51c33842e3df2b69a4eadd01786fbb119b321d457b40fb6d 4e7596567f9f86fead9cd398d3e3b056a2867fdb +855d77c6095e55b8d217076bf2f6bdaaf5852cc4b7c189660454cb311c6e3be3 f101cec32d82654159d264d177ed9ae0de42b6d7 +85b09a51ca2cbbbb68cffe492c905d4b20e8c3a4f988f5baf7f5032e2683e84a b3039beea6d0637e131b24e8b6d61005cc1f6515 +85c1508d2b524c0ca3001873e6f0f8d2f291be2dad43d12375faf37ce19f72e8 de2220a48fcf7901432f8093d3223e65f4072ff7 +85c2f81898a85957ef3bf6783a34d161a568cffde615c3248f7ccd0021b36060 18a7f61c29ea8c5c9a48e3b30bead7f058d06293 +85cb06c94423ebb8ec44805dcfb22cd56419a0d502cd6a7eb3d1e157fa0b0c27 cbf7144d8b79387bb97f115273515b9453e94b2f +85e0897e275601bcfa3d653d02bf6b49530d66d5ba2fa2977a6638059cff46d4 4195117c1ca5211c7c74366ba45b4dd2c8f4ec0f +8618d77ee61738f3e6679b5892a7ce404bd0177775fa65d647892fd42dd4736d 56933fffb8f2329d098fb9ad6085045a14c9ec2c +865c71423b25f5c4d2565a0189352e4162207a3e3d711488eb05f6e6553dc664 7f09466ca8150a7bb9eb9728841b0099b340dccc +867eab070ee07beadb0193608a62052fde41f94ee70c3574395679fc30c6f021 186a08f4b6d4a08b1692365cfef59755bd8c0485 +8699dbbfab2d020fa8fee7abebf6ce00fada2ca40eb0d09de73224daab3838ee e8cc449fe9c99f9ca35088e3247ab9c0088081fe +86e228d9904af64586e9a8378005ba654681ff5be3c43ca930bf6b1f28d4395f 6336846bd5c88d32f93ae57d846683e61ab5c530 +86f7012dddeb074d3313851cb47e7e6d2a89fed1d23b030131b7b9796c63beb7 71d0a2d522bfbc72bd8f518ba69939b2123e3f68 +86fb56a271a202b67ce596425048d4a2d0b5d0f320a196d3a4c9b6ceddedf1ce 5001298e0c09ad9c34e4249bc5801c75e9754fa5 +8727c60dc37a204127adefe3fd92fb6e1740225f3a1d8985ce29458c322ff169 ce4be0c1c06f8e311b68f70c89165cff698d5c85 +87ca3d9823e24cb99700ca833ba7aaec3cb8d34eca32240779930de95fe7caff 27aa76e5ab35a01a87512c5f6b215d1c9c736bb0 +8810957e46cdfefbea090991ec0a237fe844f0b4cad1eefa99f05f3c421f3e3b d76261e048bdda2e6d2211aa308e675507bb434a +882f8c78660ab5efc60c2259e8fdc601ccf75c16c5f787e689314197cd345793 796cf9d0a06b922a730ec98984876982c2d5bfd5 +884130c0e07babd81f0679e1ab15f50bcde3fd076fd540f42c5f7a450647c811 f5be02b49b5b3ae73bcebdc94a84893a012bf46c +8864b5746d7c5780083bb98449a3f5bf78d8281e8c5e3fd12a8ccd9103eb3a1f fd0ec0333948dfe23265ac46be0205a436a8c3a5 +886637d6a4c8dc11525f740a2e3723692bc67f42753e7b7a75d4e9207027989f b2899380601ba014c011ae9cf00a675689764856 +8873ad21d0ff871dcd53e0b2c4446a7da3439519da9c7ee509bf9a09cbe20e16 e2fd2428625c296a3dcca706dab7873368ae2818 +88a6c8138e7dcc2f7dc252dedf17830b3bdcd67021df4538c05dae27293ee343 ca65c747f8fd5110284f21d624fddbf87f41f836 +88ea074339e8277b932e8ccd92bb661e1b3dba88d86d31e5029577b41da793d5 5e15176dac8b0baa6f7950f5f763608c83b29093 +88eee581883a2bf8cc278592faec71b3964b36033590ea99e211b298101d2357 c47baa4adba9bc69f3e4a78e4b6e295b1f20634a +88fecc715077807bd7ee9e6a1dff65fde000379e0bf2a15cc2404469cef4c82b 5018a35e0b7e2eec7ce5050baf9c7343f3f74164 +890bb959ac8c20db603bf083bc82f55f9f42b6dca6581d941d0b361188abae3b e032d863f512c47b479bd984f8b6c8061f66b7d4 +89117557e4b6f0e5fde4d058c32582418fda69ed651551c0d682b0bd9a4f5343 ff87c872c7846c5725ec711b6d2005febab7d6be +894fb499b85985208f105302d3cf3d9c5ef13b6e4c51ba4233656ca6aea65cf5 8add01539268300564482f854412cfe9839e980c +897f5f26ba1178254ba5170ce0cb7a23a83dcfb1e528c87ad3e26b89c62cf9bd 44debd80c4908e439d4a505ad7f6de367635b0eb +89cdf765f35bfe191fc18ece04228795566f412e0cd6fadb80102a8268c99085 605324ba5ba92d44cff024069be576817e41c7de +89dc8ca30d409ad37a872d80b88661ef50d6c226a37989cd089e60c183609b35 6ca549d9a75628c1703ed6d2d06877351a268a88 +89f819abdee0700e804a202787da29c6c14aae8dd6d3b8cc04c50cef70c44756 802589d07105d24bc88c908c9e62edb3fd679895 +8a0042d434a2f8a2e8d47caa4eb454f388752fb3fe71150c1cea12e807cfdf1c dec93efc79e60f2680de3e666755d335967eec30 +8a1e1a6cc00519c4df8ce404c987751446fa299662308622cb63576fb52996d7 6f2cd729ae42988c1dd43588d3a6661ba48ad7a0 +8a5dc4432a7a135282a588c0249f63895f8cdd2d68906a2e94924ca31c89189d eb9ac8b7622f3c144605733fb4321b7cad8c41f9 +8a5df168a787cdbb8fc1560d31fa917061c53071da52148a8b63ebb16335091d 16d9bd5394fcbe6cc3dd5cae5124bd8400343e10 +8a9b600a21987e6ffddbad745f38c115797eacef9117043bd9d2da4835ee3cc4 0fd7e4bfba5b3a82be88d1057757ca8b2c5e6d26 +8ab64652ae74f7d9866fcecf118eb9994a0083fa7e52a4bc49a29e9887a2dd7f 9bdf5bf0bb8dfa08e11ea902931100c4605d1d09 +8acc0ab2fd3b22535ef3f534e51a9843fc8aa927903e1157434c9d72b1ff1503 257bd746cf4b3f1e048a640202493c3e3bcdc1ae +8b399358a71ffc0adbbe2d3160310e19b5a08da84565b0b74f4ed24d572bd476 ba0bfb30cd31b4d6bcebfe9ff614794e4f5881b9 +8b592ef1a82b329ecbc463843ddb64c4378787bb632999461b743c8c41ec0d82 2683a6b43d73cae20a876eaf50b541b8efc18e82 +8b9acba2b7d2bbc3947820166fd0b7fe6e274a1387957cd6488730d243d762da ce02d0ef9ea8dc621df41d3f244858bd60f41d48 +8be5e8938f38464bf1cc68f917fc9538d598bd4e35462ce33777a65bfb98b504 e6e4e04556df092bce179810d25ce5330b34d8d5 +8bfa45d9dceeee0ca326757a5c7feb70c3bbec6084ffba27c44acf73270484c1 80829e69e76fcaf3eecf606794fb5beaf3561f17 +8c0f41bacf4388237e1e53c564f3a0fbd1dad819856035fd41370942389cfac0 01b905d074ca43b1b84f507264d3175e5659acb7 +8c1b59c9c4abecdd5107384206e51fff8ebb6eda359c6acc8ae9d608f777920b 3b104436374b9785fcca167c9d3bf1e751c1e56f +8c241c359f8adedf6fd0497cc05f5821570e05b6d92537d7ad8d5d12fdccebc2 bca03c4e40b1f29603ff131d702c46591b8ff960 +8c53c0f9f0972a1c77e40549170b9ae51d365c200ffc4cb220628c5bce3dd0b2 d047b47aadf88501238f36f5c17dd0a50dc62087 +8c834cad51361fc89cee23325b17dfe11294cf9241f2b7579671e6b2cd45d79f 8844825b8244e0cc54c96d73469a956b507bbf8c +8cb46741dbbee92758abcded6eca24fc2b74f43720c8525633a80410ff0e2b7e 331578fb1d3ff7013b312914fa9c78ee61d8ce52 +8ce4527e0214a617e08c7aca94006d77ae31755ddb5f757f635c0bafb35f2afd e8919be6068c14b5c99b828af9fb84769ce1d79e +8cf83523411bffb0b74c7f8b5f9576b23ca2b2578f93ab8ba59bc6948efc74fb 974a17ff165327d457cb3d50324e122542255524 +8d4fd5f56519059e2797709107cd15d1e62715e26d83a27eec8160fcaa57a7e4 06a1c29eb70dd0b5f43cb58052641dfc6e8dd2fa +8d79784fd1848028802597c0ca8342ae4b7c7eecdcec8a9f806f537798f74110 b5e02a3b76c602bcd6230826850672f828e67d23 +8d9d39e6fd6ad7cdda32b877633dc72a1fb7f4da9ef96aba6c284ee9f32ed71c d44cfd460e2c52d67dea14838b03219967cf9cb9 +8da4f409d9349020273e9fd00dc8f7a0aaa655b5351af47c9a220ee542a31ae9 7b2a0b6f0d56e59dacf05a30087b58c1ff93cad6 +8db27a1dfe3454a225917713da4b0ae56c617de64876e549541e8ab991f2d1a4 5ad63728f19e4c606be7455a8a7101c9255b2b21 +8de876e616d65723cf46a842086e338036f8d9ad6c6969ba07ce2abdb27271a6 0f6d2f4cd1a1391a98c6a89e2ee6a69c0afc0c9d +8dfd647590d3913a31bb0d11ccea6df7655b8c1c2898c49e85550fd5491cc3b1 07b63040096107db747c6c80b02b0619e6983ec5 +8e3ce5aaff68c05137728f5845d627de532b2294b665c3d05eddf79972439909 b27d0a8066fd0fbddfcf8a30b4e77760147b0817 +8e50c5148de4a8ba9fc799c67dc669d6f82cf0a10ee9f03bfa2b5a3641762466 d1621f2e35b6db0d27cee8c6b1b03c2199d7dbd1 +8e579056a6928f364735405ea0694fd779e51a2a873fa32f3c1eee7db4ac186d 45bb348411937ed17e912aad83a14c151f922215 +8e61988c998c96a131cfe72225fce43e555bec4e590fa8c239373172a9d485ce 11261fbff21758444d426356ff6327ee01e90752 +8e67ab781e8d1b4f8c35972ebc695bd8645f51718ebc866be72ca3863956c3f8 b864df623e3b89ad678a888dce4b0d4c997f1ac3 +8e786640865ee4f226cc81422201c22dc4229852bcc61018a2ab7c73cc9c8e7c c3b53a3518b99b4ce31aa3f6e51dfecc5bc772e2 +8e7caefe45c938cd9dbba149c377c1cb4392457f11b1d8a258f464a24752a40c cc57d8aaae44f013e3caeefbf401ae96d858ec9b +8ee7bff2cdb8e47b525d8d472fef394ba46ead8db298dd5bc09c89313bc4b1a5 e313f6d036812969a06ace47a56c539fbdf8e82f +8eff6924525965875cdc054d19a4b3a00c5e7c57538ef7ede78461bb6829c818 5ddbd5edf83e034a62499a1a9c94645d7b9030dc +8f74f6adef88cea42ab0854fae5f0e3f195edf161acfb12d5f65a5e9717f0cac e235f89f548d732c4e05baa54b8b3dbbaf5537e0 +8f9cede149494538f4de2ae7c79d5abf3e8309762ed0846a9d2839031cb7b456 7dd46af6b7c177bb38c3875ee6d79a78dc1076a9 +8ff22fe4eca09e4f6bec8e71cdda911f37d836532f568bffa0da55d90822320b 6bb7aa1318f7f31a346c71ef81d2b33c6fd41600 +90115fca32a9cd85c4c9c0ad4c23e1d2772e2e91a105d3ac3c92b76f895f8b92 5c0b005b617d01c512a8dbf9e9dc1aded652f244 +901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 c47800c7266a2be04c571c04d5a6614691ea99bd +902a50088f5721565b264e26665043ef0de4e9d2841414ede099b24b3793b1b2 e2401d52544ebf052730a63e8acfe4ccfb8fa0d0 +90445c1dd3c04315c85766841ef3f61e3bd6cf0685e03382dba4376426d365fc b6c9e4203b69a576ac5c462241a7e2f676cf551e +906ddb4156860b47274ea8ecdac5f374ee64306d9b9f03c34bfc9df5afdeb7b4 74eff33f8be680e821d9674ab12da3c0b76dad23 +908288eddd0888db0d536666139e193ae7e2867d214033fae2557701a5d8a9f9 80133dad8aa9b6d8bec7050a77d603c53ecd8512 +90884a4cca02648ee29efaeb429c0af915e0d2eff2d9aa281aa8dfb2d86f415b 470704779e16fdd3872fd111089ded59aa12a576 +909cfa7665c9be2db4a58346155ac887ba00f6079b76f71b4f7d4ed9939cf0b9 eb942285420814778642962e7b4cc95636bce88f +90d744132ccf86487aaf3f51ebc92ca3315c59c48e12b4d576e253be91a0c460 50acd0c53572be81b5c54379b2442b19ee240953 +9107412362d36b5e2350e5b3e3b6950ed4519963bc036b84509f452bfb73e580 a24f1bb1a8d16429bb17455a5f332eec88e777f8 +9112f74e9c8db2d4574bb1d568099294486e293e7625b3d6baa257970ac1f81a 1765d783910805c69509416785b2b780d9b36866 +912aafce2240cef7a68ef8c0e53e10b0d7450818c471f5b09f8f718458ef9c4e 1e564f1ef0e3a4a5fe861b46024daf93bde4834d +9197064ab68802fb19dde16fbffd2a40053b37850ea393274d10b3cf5fbfbaf4 d337abf625b6912fb8501993b7fb2b472d5ebcd3 +91c9d8df151e1161258091beb0822444b9af63bdebb8aec39417153503c0b669 f528160ee7dcb57d2c56341befcc00aa80393b5d +92128dfb792caea934f5218807ec993867b0c8487a3de69ebac33e067f64d38a 700f55d91d7b55665594676a4bada1f1457a0598 +921be768179935cee45bce4a0b2d27ebdcf05ed06c7d10fff2d9cf900298024c 78f9923320d8c6ff69015ffa8c0410f6599a3499 +924786a7e975fc305e917d97cda11a71eafae57d7b3c916cd84536a0c2487a76 685145309c964db9a49d6b7ef96140db6830c131 +929ca73a254eb7b0dee0a7476e09ba2a53c0b6975473c9d7574afc0228c34e73 c22bd2f5514799cef5657d67dec855c6b32a7eb7 +92a2ce8258f27dd45ea652d5336dc3685dd3d60627011f6215e923318f7325af 15c883bae698321aba3b162df438254512b316eb +92e6474ccbb1fde2326731bf69e57142cb428ea3e916b71b2980e4348ede2a15 0e3ce9a193137134d355caabb98126cab35ac236 +92eb919acbba3d8094a46d43a4fcfaeb6243859c3c15b2897e0f7f50be66af37 4e67695cb9de10a3dd32f78cfa01eed91ebf155d +92ee0adc53ff899c85d7f42cece06277f063d89e0b496e735fb68b25d02e2b93 c1044cde11b3aaad524cb3ea49d75227ed7e5f48 +92f0bd5f6ea173aba9d25ffe352a2a7246dc32e30f0aa2905cf566464db2182b c117a5386c76f01b4c444f608f4cddae9d1d2233 +93010571894137ed6a1d91c6caaa46adf9437aa37e672ec4ea55ae0fc434d601 f6baaae117d058baa0865206b834cd8e32fa4e6e +930d5c174308a2d7109171b86756093b656cf7f129524b1fd121f66a840f63b5 2351b9dd3b52f5421a6dd9e2effb503497b1c447 +931093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe 1a443023183e3f2bfbef8ac923cd81c1018a18fd +9315ebbeb52ce6c79a2998a3bd9486831c6d2b2b3925326a3308aff6e5d879e7 524570f2c3b95b5a9f1c8df74893451e04f1017a +9391424f1c846bd6e8aa6a2ab9d1c9896f415068f516217c20484705763082d2 04c9c16e55c53fc12c2eed43e3d7e42f78fe7005 +939db02ed91a33c32932ca7c00f3c5f18bca0c2d348c06efe566f70bd3b2d18d 96f702218fe6bccb09568c2ec24cc186ace8c575 +93b0ac3a6caa8be7b891ec756913b8f3f3071a20ac1de863b16c8037e2f4c21a 84a13dc9b196c2b0db6b0f664e4ab2bf9d6ce9ac +93c3547a4e0bdce7c7dc444b4cc7204be32bea44e740daf0a41cd32a069fbabf 948171a894ff8a25635232606c5afa7bc3224e38 +9454571eb895fa350d59a9fec2b5b2ca135e1938dace531702ca77bc342424d5 4633dd81e3462424635f7d231a2373971ce736d4 +94a67a2dfa7ceb5a3416e25db885e3bfceba064499fc4b817d7945cd271b1b75 1801cf406d4b17f019a789ffeb9346c1cdb29491 +94db24aca3f8e07f481744f62633730feb4fc47605280381a08be510ae971ffe 91822c50ebe4f9bf5bbb8308ecf9f6557062775c +94ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 43e968a905a821532069bb413801d35b200631cf +94f81211f6452f3b46656d5ffe4ced3377ddab58a2e9063a6a4b15cba49cc08f cf16919dcf33635a64999185522263bee1428e26 +9558e844b96edf250889c0660f121678993205d280a3e488cec0605b979f370a 7b6c856c6e276e9a3689914797d2598a37f4e1f9 +9565fe314fe3bf77a01611ffc14a48246459ad6a19ea01d4082522622fbd001c 1cd20d3af067093c571be764bef038be1a39b502 +957a8f955cfabb1507ba2fb3bd3a859a9f74b4707424dac86ac543db0d69c667 09845e76453ec9527128f73fd5ac7114e9158432 +959c738f7d2c764ebe052a66001643400118c7851aba3b836377623501a14222 1b9e92c73bd223661fe63dffa0c9138da4e1ea80 +95a2dc8f7a4fd47c27fc95dc9d90923d11032f4f436c410c60beb6f4d5b6984b e2337f39c3a4ab046b7a572fce89df27451fd2bb +95bb14319c7449829409166e9e1d1a750938bc52ba7523d752150636556803cb 5440906feb5e41241a699ee413475b7911284c41 +95c49d1abdc7b172424e8d7db1f142590e40c04a882441728b1e9b2268848cf8 8953b6cefc86a339924d5d0ceb7fd523a149fddc +963954464526b415ff976b8a59efb85e521ba5239faac654bed92979fa976f92 14dc301e7f99cd5f88098e32366951f803e9832b +9670e7ceb635f35942559001b8c628211efb5bc4f57380909523fd828c706f93 73bb602a74eda507838372d66093c8e85246159d +969287ad751eaab33d0109bb39436e2babafaecd5ef8405734713431c64250cb 468b12adb15f5546e7c5536f72204605fbd83f6d +9699ea5560b7b35db0fdcd4c7d50269402d5624d72cb1a8646b33b65dd416c07 42608eb49e4be32002462b51e86065368b342c05 +96c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 45b983be36b73c0788dc9cbcb76cbb80fc7bb057 +975c9b644598f22c51616e9c8afdadff852639aad6c08b6c7bae1a34e2d812ee e34dee0c7f0ac8abf228369e1016eb6016c40758 +97a021b36da9610ff840213c9277124fe653804e85f2081f6dedba953b5706df 8a7d625f53726fc7703dc0a413686d1ec15488e0 +97b0e3661fa0caa6200c50381233f8320b907540ceb9d17ac94fedc66fd093c2 cf6cccf1297284833a9a03138a1f5738fa1c6c94 +97ba6db30e1bcc6f9e5916915fea9dc0e205599c97586f7846b9a456e5e9b6b5 b47ba8387c1d7209d4976af9c3928f6ce93ed545 +97e00ba4c8028ea91e7131c8c7596227cd03d3d2d14ed2d179fe0f305ebbca39 6f6a17db05a83620cef4572761831c20a70ba9b9 +97f425b009376be705660ee81095773e10fc99bee7ad513046fa0108bdec5d22 1594f6c292f52e077142ffc0f35b544e2c5dc108 +9832b7f86876eb62f53f0fc649fbcae18dd43f2ea05ac7302239f7f91848d554 db01475e9527b251dc429b03a96ecfdb2928aa1d +98488e25f5011c5d690f33397fd78528c38921473a0a4bb4b3a4d70b0f5a8d84 8a8cd3e5f3aebdbf53e677b176e3a434231a26f5 +984ef110535289c1e7afa6a33058e1ced09d7e0da058e419d8ddf8e8ca060b24 07f4f5f82f7825893865e8404eb2bfcf4a2e6932 +9862a961bf9c8b544304d2dc638c340b9c9aa6168ab4eb93e309326adb2f4499 657cec1480bf4d4bc58119da119f12a5b0545b8a +987d206013d0289d45845304b00c8f9adfa2255ccbb3545db0157f79c7cb8ce5 655d381a1948783d7d26ff9ec5ef54ed6bbefb29 +987db14ff31dd4b8eb26b09aa1abcfaab773ba9c27b6040d47033678e7cfd0e7 121c862c3a2bc66c12b64903e508d8bb8d2904c3 +988a04ad188e91c521853685421f1b7d8b0a00767a6fee4c58a98bd1d449c3fb 710a14e927dc232d94caf0fe87a42f0ffffe4b79 +98ab296fe0c2cb1cf8c37553f659614482e37c84f0b50fbb63e9eb33cdf1f85a 94b6d09da1161aceeaa537f55802d794cf021627 +98bdca06d862a2b96154af5b34e7567f60421b307d1b067a0218d6f3532eea0e 6cdf0445fc0de286fdb7a343a5dfcd1937666132 +98ea93628189727f2a49d3fc8800e24062ee013433b4914e2f8a6406be1b733c 944a1233c2873c5e21f941460c3940f8a563bdf6 +991cd4eb50d0bd943326a09398c691e3715278549d2e62720c1a90495996fb85 51eb2f90a1469542799823e0f3249520bf8f9cf3 +9932236d190601ab8f93e8ce8ce0fa59dba7f393d917390c1d53b34ef05b41dd 5614dc18f626902796fee9c87f1f703694e59295 +993f6b6de11fdbd469b7f1fab0d06ae9c97e47b4b15fea92903cc8a5f1dd981a 5b9c679bf878b9eec21b022f662da96601343fdf +99556a8adf928dd8b307733e4ecb5a8ef495b490011158d71960ee1b0a0e0718 e3fe32b6a4ecb340fa7c9802285711cc52b8a101 +995d546eb0fbe7f94b918920c68b83f8f92a2c433e48fb458374d347982cdc33 35df53402ea1bd8079cab9bdbd887c79319baff6 +995f00a0542d56fea94d5ec6bd4912016c7bfcd9f0609103766bb8c8a0d1fd50 daee7af942c5f7d25a00e3ec4d25eb587c61ac94 +99676bb02a367fe46c82e0d17e7c0f3e85a6c39c3a7f51233c85bfc73a20401d 8c870fcebb8f625a8e172a49a44153af8f37c8b7 +9969afffd2839b9abfae52451171231fa3d701bd6b3d0be45c2381cc993278cf c7cc7cc6e3a1480a18fafcd08574a337648f68f8 +99836286369db283d666122f999d6bae55d099525ecfa19678919c75de3ef920 558d6aece77743bc4be56a0a62ca9838131d217f +998a830952adcca170929a187cdf235190873515a9d8577dc7610373720be0dc 05504cd34d6ed35cbc7c99708d226758a1cf8b57 +998da46ec222491d7911e92bdd6711408dae8e47f65007634cf0286f78d042f4 0daa6cdcad92746551f78edfa93be0bc188d4f4a +9998dfc144a21e3e124bef5dc0f9a60e0feb92d600ac1e0fa77a329b69f0d256 4319860c60d84ec2513be34ee1a65dec5eceb6c4 +99add46dddd278865eff998db5c7e17e806ab0696d7cc8514ca638873fd4c6be 3fdbbc28dc8eef8c0bc32fa6940a9468307f2dc9 +99e8fd0d2d4d41d946a1bd932c4dc4c600ec25ec1ca10d3dbcbac0542c85f01d 84675cbcb6c1213c1e662afac915c861999fad7c +99f3b405443221141eb0fd1e0cca5d355f893983749b7fb455769fba434e7945 0266163a49e280c4f5ed1e08facd36a2bd716bcf +99f81d6e58403d464cb05e5425c6db0219ac6a03dd4b12d8db19f8ad7894eadb d435e706e0daa21e06d16f00d0605d598fc21b38 +9a2db41cb4dfbd68346f5aae4ef7a75a2756853da451e62b52999bd40712fa08 f57d4aab1617ffb4b923ba461db47073df131478 +9a3436818efa95ceed279b481957c3881d4387824b3ac7d6a4e5c4cf57d1339f 9a2edb897c93a7d1bfc28aaaab1b9634dd684ff9 +9abb7801e72353060a1490ffa3331674d6882558e7d6458de397b4b00d31ff8c 50330c02bd4fd95c9db1fcf2f97f4218e42b7226 +9ac1548112cb48d9fbe867db82c9a73eb6557f77d941f8fce68ff14d276d3e87 2e6776cae6c71d745beb9e102a4a18429f3c4cb6 +9ac284bc88212994d14f96edf294d17a7a4796193e3138f84f9e60eb1294cca2 dbafe4e0c5def65ebcbf13789a84e996cdf8aa25 +9ac9dca313f55249c085fcaff33f161594a35636e465e10368e4ab9e7b977b87 91f3b517f65492e5225d853826e3837d404c6ca4 +9b66436f2b9350f6d20d44171b51b0dc1b8859499ceb556249635125a86578d0 f2e2e7e17751b629cc3c13b0a7d0cab059cd1df4 +9b91942519f6ea0ba7841d14598c082615cbf66066995e85859813d3eedb43d1 62ee0b89958479ae19eb68f18bb23de238a6a2f0 +9bd609366724dee19ab10d3f795965cbedf785ce8572f56dcddd42f48454ac91 16b9dc5202084b857d167c8af606422df771b8ab +9c0f06e8344fe1af55ae50f4be06d090a443c24455252539371c9aab581699cc 1213764b28dcd72fce1be359db724fef38265ad5 +9c486e5fab95b06f1208424d889811dfaa8d498ba8a64af6faf2eab78e005baf d4594747a02e72be9399b3a54018676e0799be22 +9c4b7bf896a50fcad21d07e1a9c21786876c78350dffa6bf7309ceee396942a3 3d3552e8fd709214634435ee188e6fb4930e7b39 +9c627d7d80e595ff49c610c35fdf73d3e04757b12c75b724270cc51b1778f781 8c08cf624be754f3ba55777638f6cf54007dc516 +9c67024053a5a19e5c5f27bbd02419c09194a13d4cdce62d5873b9d6289a5e55 e5ff267406ab4a456be0b46e38fadf8fe822e13b +9c72eecdf03014bab3444907a5c9b1abacf3068537c5c7651f9492326205cb5c ca88eb6224eb55fefdf6ed43963b5d34c3558d03 +9c7b63b5572f9c6e49382f5ccb71e77747a7fb3723d13dc91f62fe6e3bbaa5ba b3099082e5108151c0cc93ec6bbf8b7d6a28c4fb +9c84470c221d8722ddc005be2e4e9f662bd4ddedbdbcdf0999328b84b7aa14ed 20bb1bec4aac38a69c0a6fcc62919a472e33a136 +9c9d32c9c37ea95e0e7a22420e60f28c4ec7d16076fbdbeb9e16485fd7323975 3aeb4c1456431b730322d7a7d88f5a2ff60299ad +9ca320473e41a10134f39c3d2361a6bc82c68bf5328ece73146233bddb2bbecf 485eaa8bb045019e615302bafa10302f86a01553 +9ccfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 db793a00a5615eca1aac97e42b3a68b1acfa8bfd +9cfa4ebe14380d4922f098d03f17be12019fa52ed3e602b9925ff90f55c5a314 c94eb4aa7665d04c8412a72f3554401d2e89e03c +9d59e5d73d2bf09ae93c4a9d7afd5d4b7e983a20fbffbdf97ad78eb4d949f3c5 1554ef7957dd89f4d94f00dfbcf7989d3a409306 +9da6f7f0cc86c1260d40470e395f1e86aad5ab8e27d29bea60cec1d35c017b64 b946f1a6f5fd8b14500fe986d18d1d008cd00f18 +9daab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b ae90f12eea699729ed24555e40b9fd669da12a12 +9db520a5a88c7d75b86a4faa1ce9010edf38af922f400c69a4a93aef69e25c4c 32581d0093429770d044a60eb0e9cc0462bedb13 +9dd0778372a1290bbaef59f6c04ad41776480beb00e529f6534550ccdec849bd aeb13951b1f97e44e4274201683e090cd7644046 +9e0c79efc2ddaf22864c1fde0db347832bc1a4e132fae802e95b6b0c5853c2cb 8399c6e8a4fce8eb0448429ad557eae77d2d78ab +9e2bad8166fbe654963d974e55a2f08da38a9e3d1db676a5a2c14ac3714b01d5 ee0be6f12e1e53703f2320e67389b85643305422 +9e77f6b7446eb082bcc2cccff17f7b83c69fbcb03117ea110012cb8bbfc37515 93407057f0107cacd2ec2fd97f940ed842caba94 +9e9f5a22329db59e32b25d8bded97e479d9fd505c6b61a52e6fd3113af5e88cd ed6e85be8971b49a86ef11745b5a27bfa4f4cb2f +9eb5ebb282122e48e20e161b3715061c4381c5e6a24512b0109c195d2f2ba73d 154eeb7642b8abbce7954016ba549e399ffeea24 +9ebb9db12bca36755036e35e51abff05eecdd42a23c620a2a372d7cfa55fee52 213e720ca80207fe1bb48ad95e2c422e17281a9a +9ec93e31545ade8f8122f1ba534269ea72fd84f1ce0b71c51f40f74b23cae7b3 a399208309046656ecc01f7653c5d5b8905fc16e +9eee45dbee480fe07ecda366c972abae9c1a4f322f4e2a00143638b6b877fe10 8929a79acf82b9414cc37bb9f464c9d0bcb384d8 +9f063b7c95baf5482f968577719e51ae9feafc11121b1d1c2b1460ed47ac713f a870abdd5f33c3cdd75c9c6229207346d1a3e5a7 +9f61cea7f0b3e6e51d51b3c63cdf7a875704cf5d8bdc20d1b4a05daff2275286 f863bba4dd0964e82908ab6ddec36bfc26f8bc48 +9f61f57710e2f3a52ba694faac763f14fa68329d758e713152956f67156aad3e eb160e949ef7a76c384dbbfa0d61d580a11d095b +9f6353cd9e03b3325fd0ea23ff06cca2e7871b39d0dd546d023743ed4d0e9c81 47d75e0475f54c1f51fa4f3a508e3a71bb3cf27a +9f68e485be09cb4f0406832c3043ff73bbaba9057dd32ca5120bf58fb968dcd8 c341bd71e5bc97d012fe7d788f5d95ad61f421c9 +9f7d9c3ff7c7873a474c6e71d117de23c0ca92afd7dd838e6425de0259d807a7 d17bf1cee2b79f0c371cffa58246faec7fa70292 +a05508af8a460097b5be87d0d1adebd9965d001c00c0342d5823d62f5d504147 d8b9e83ad587491de5e0ce5e105d6732da7efd02 +a0806f2837164079433fb98454b3beb353b38625d7f1f2e5b2737909a2fd7f3d 9b52f4120bf54829149cb3ef756dba5018fb812f +a0a1c80c937e6f8c7f4b9deacd53dd76b6f9bda0710ef14762f26b5c7722d85c 488de7f1158680124370c16d9b5787f2cffb290f +a0b19bf38b63a7127318ca02600424c2cd491023af9dce6d707c0e5891751207 bd65f47097a6ff27de3e1d908ec1d53cc6b0fe48 +a0e4131177d5b53a0a0008fd5ffa88bc29c07ee6c3020adb8f45751e28eb16c7 5c7507cc2e5b04fb9acba04042d900f15271da8e +a0f3dac8fa0e22dcf356aecbbdf79440715687c1053bc59b83354f276d688ceb b196a807b323f2748ffc6b1d42cd0812d04c9a40 +a0f8444fdfdc6276b3b2ab225d14358833ac50141d73bc10cd016a063437e6e9 d7fbfe155fbddb41936407612fbce9c34276b671 +a1034d13a76b0d29b83f6dadc5a44826ada4accc7889f4b2f6ba880763f2ec36 634e22b2323599edd0d177e2eaf69e7ddafe49b2 +a1053628fac1667c26c16ef757cfb87f4bc6553b90a659cd39bb1d46c39bbcf5 ee1765e529ab6b44adbcc6a0ff6e9ac1359c6cd6 +a13eb24e3a3948f74a9d83f553c937e82cc6e2fbdb7948bd12f2794d822fbb6f cb5245e80f90f14c1b8daadf95bfc08d29c2467b +a13ecbc514b571721a9a1c92af7f89d473a5fe13228904f8d17368e71f273ea1 702bd70595a7b19afc48a1f784a6505be68469d4 +a14fd01f6c75813480bc15c6f3ec6f8a2b18c541212c93fd96f6287fe82bc104 6829e2c4923538bd75c6ad6a2590c1aca8d4a212 +a15a130a98c1cae5e6dd70c309b31bc21fcb9ea731653d21054e0df82d4f252f c18626eef6cbd1b420b85fc9f8a44d5031ad2fcd +a1b4063379bedd4c5c0940aa2dc8c07b509d3a5164a853f1b5a20d156a7c5c33 b4440c0becb8f009bab65b3b3c901a409c49add2 +a1d1162067d6018f0b1d90daa0ea14dc570052758b6a3171d7895073fc15d992 7350e6337a2d94c2d2a105845fc78ba0ddc89ea5 +a204c52c18c7bcbf5cfd33f2739b6a67af9938ef27d904cbf102f5dda766044c 0c3aa34742a8470a4ab4acc60e061bbd9a85650b +a2127a5161de12892e23011d647ef0e291101a6120b75de2a8cad765e56311f7 880dd9e150364fa22ada592cb5daf913e775cfbd +a215658dd4f0927c758ffcd6487b359161f0ddacd2543cf0fe86bf085c174bda 870880896dd1c399bb940510903a3639ee61bf68 +a27bb9f32d0647d311aca00a8f7664d5b30182a0eda31b1352f003bbf22eb58b 36cf0f3c2a9b192dde9ab57992dd730a54a2e302 +a31067ab4135316257f12ca5852ee49031e0cc3c62fc7e36857356a1311f864e bc7ab9aaf82cd5778fe998117b465b5feeb58c41 +a33b7c23c1f42033a24b58f5ea0d33aba4b6fe18d4bff86f0f70a4d266b66b69 64b5d4fbe7bb8ac0a5dbde1fef81dd84b593324e +a344b247217e51783935ecdcea5837be2f47a56172d3dcc2069936ef3d25dea5 7c866536731236d38f1d75711a2af253d479dd8f +a37c93ab010ecc9c7f017623c38324ae2b7d06385eca57fc6da35102a2c54a54 e5a2858907d153905dbc09d1445779caac0adc6d +a389c085c2a136c9a2c2b4a818b851a87af9904f933d7fd6aa99846208efe800 f501265f976a745e5c0d21104635d695227171cd +a3a074de072e21878238d9d7b7b1081fd4dbf3bdc50c145e85e6e4d7a09d7909 0967f654549002d2b6e8495c10cd0bb20ff3afff +a3b7619b6d836ece7d4dcd5d35eb3cd636b6ad1fb22bfea768ea5d4102cc9ece efd690f67a58c2ea1c3984397c2aefebd716d7ce +a3c8832d145147c568d4954618aca12117705d399fc02f00272fa32f3ff95ae0 dca7499de88fd02b75a47bee8def272c14b5f7bf +a3d3035f44784137774392f722a38f0d5a43b9df0a631531d0e47c48779cd940 141d3dd299cb117c277cfe0907b0ddaccdaa75ac +a3e39ed0693d43349755e98d7e125ac17b5d3d2a5dc232b8d5b2ba01302ace04 c15c5619a51d0a0dc6bec0d9961f9ef50c5c2178 +a43230765f7a5a3d422ba2e7cfeed85ad722551db2ac6784b04f6f8b0e1001b5 ea2adb2520150efa688d3c48f03a66de3312bd4c +a46ca0d0e30ed9fed1eb8939c497f79aba95b9e8e4e712079d73a6e6ebc70d72 f0374c882b77ba4a05ea2d50f506239da26a60fd +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 a4a7dce85cf63874e984719f4fdd239f5145052f +a4c29fb8becd3a01d36d8cae4b12b4d3709e6b45eea54d27f2ae2e43c9ba9ae7 e8b638f771ea8e8ed9049b56148fcb2a86625f7a +a4f0c2fd0cdb1ab3dacb8758af443e9536c5987f7c66c5fa89e2cc79a1b61c92 da7791a0235d172e7be4f5c299387ed1c95c0921 +a4f8a0eab46e58b3afa198ed68ef78d6fec944abd7ffa6fab63a8af923aa973a 521b4e69c6e0a257724d59f3c803f4eb11e0521f +a50ed806c69fd2c6864e9658b0294feb4f7c24970cd4a785b3788beb190266d1 a7fcf7cf6ab5763af5a332041327182130235ab4 +a5191d9e8f879091e1ba926dd387711ad308a6a0b110dc58a4c9897209b14605 523412bef70b1d4cb92c574c89bf7225e205d489 +a52d36b5dd7c95a9e8596f01aded392be81ae538591f5d990459592bed96be7b cc5aaa5fa825a103a547d381c7a5c0524c4853cd +a560d1fa1edf114f57b402e16d662c17b1e3b7e8601ff7dcea6615ba7f1e48ef a20d733a9fa79fa5b4cbb9639864f93325ec27a6 +a564b979c786a7a32c6e8477e940a2a43238c57e8fa6be1f8ef7954944c41b89 571a65a81061ea62a11fa210ea6819322be4cba6 +a5ab6e423fa4649571d39b9a29484a0bb17cc70534ee6a410882d72ab1e31597 45a5f836b0bbdb163a13ce0e1ba1e8f7acffb5e6 +a5ad182a309ce0243d95b53ca5eecd2a139795321ff24f6fbc548ebe1f425729 f52cd06b7d0641754c6f7124382b9fb397e4070e +a630a33919b24191dc33f2e09b46196fbc7cb4b866b6416b8980431735146a5e 0392558815cbd6674d2187260948cf5a1fb22e6e +a657e241eb57d29d515eeb128f31ad3a8012e71be44872b0778f278df6ab9e4b 0735f982dd5a183a7fa901b0103ea4b0719af5e1 +a66bda0109d2b3c9bc87970da81bd91076b5f871febbc860f09ae997668b6800 12bf5f3e3470d90db177ccf1b5e8126409377fc6 +a679511b71b78a1b0781d6cf5e3c4524c1f213d671a5acc777ef36a2ec9b0f37 b98b09da1d6c4ec25911b2fd859282a41f4225e1 +a6ce423d816299e53b9b87164b3153dc3a4bcd733c33be1c2a13f41f140b69a4 f494e47725e1cb76e98b5aeb9bdb7f8d8271537f +a710c2c837a5a6f27f2b7f5a198c7797f148ae6a37a2209748845adc9d0bef8e 0087a575a0655d2e53e8ba4feffcc321dcb8cbc3 +a766d34d210e448439135e553915e30b62f09b926c669b7e2d5cb073e96bccfb 3bc2493e6ac633c6119b7899505a5a0513ae4e44 +a787901c8e7f31a8450a152bd8aa7033203693d8ce807348e53125a47afd7c24 eadc9ce6cb6cb722723e228d9e44f001d4236b4c +a7b3a389f8d3a36403a8b2bdc6b9b2579c81d79f91347655f50ce4356b4f2831 7f07667d4c520a81c4fd6b5631c119bf2de791e9 +a7b9c8cf9c7469bf18c8fd079039fb8d1de1867de46294726c110899d94b5ae1 3d2577feb4985c61a7e393777d78cd9a8e8a516c +a7bf36aba7ea2fc2eca014f1ff42ae012ef82b450220cdd5e77d7c5bee306c71 c10a39190029484263750293825632cbdaa9757a +a7dc9999e70a00c97b97f71fa0fa877e92e29a09ef6eae72de2ee112d3854ff0 42150e0aa48a3ee95ffe74b7f937111a4afe17cf +a7f778c6ab0c219aa051ebca04abf1397864be8c9c69873792c6bc8953426874 ae5ceb4b269403c6d1653c7bb32e71ede7398892 +a7fb6dbb2154115eab700f4e4a6a6eeddc30d3f8a14f0ccacfa98d9347ccff8d 4893b75d346a20df101789352b198beee55901a0 +a86aa44f58a3f3c347dbd0f99a84c1ff6ddd41c58b19697c49d3193f65873a08 c8f5cfa836b403abafe7256ce964e65b24b3fc0b +a8a227647205ac1f01b263c1a81b8776337124a6e519b67ac69ffd4d2274f682 ce53c27f666673c2af8d406447078ea03bd95f6b +a8c3ec591a4e8c04a28e1251e391aa6218df72cf9b5f0ae0eba6eca6877902b6 94996dfd9511a12bfa9190d97d33d2bf6599f1fd +a8c79d136e0c69d1c0d2281bdf7acfeac0f55d6239b0141e17a6de422628c7d4 696bbac1204a1d56b0f482568b1a7d504747138a +a8d8a08205cfdf47585c32111e5327b328c0fe68098eeb58c939cab2e83785e7 3f88988aa04971faf2b1170fb8a5f7a0e2cf5f8a +a8eea8c78cf7e55ec2cfa539d860b5e5bcc4760277d1403f2c3d06c583e3905a a0cfd1297d1eed63d0690c167d67e50ce06b6791 +a91887e522da2b66ed048d77858041c9cdb2fbfb0b4d463b971911217aa3a4a6 c2550609e37e0778814d328c47eb84a7ede6931f +a91e8591cdbcab2353f3d0f75a016d31c14157fa7ba9657bb72bea1772be10de 82bca8633fcfbafe94997fac9fb855bd93e36bcc +aa11e156cf0329ca3cf624ca8a185356315552962035a549ddf6f09268402084 18c321ca3c1f1d360c8f6c793cd48afeddb4b54e +aa4089cbc630982cab278c49d506c357fc9a8dc27c002ae1a6f8af32d5bb3e89 966f3c578c405f92510a54de59ef2263a8b217a9 +aa61d4adf622265ec814c1a97198d2bcd3f58fb08989cb9beda32a4d0aab6697 bf92206f8b633b88a66dca4a911777630b06fbac +aa65747207487983a77cd65713928d62e1b326b93a330ab74e9c9517b42f9ec0 75d979718393e2d0e6d1399e6c1e760cd739ce35 +aa77e77d6dbd35635d786aa503c8a85b08274c73ddc420ce75b66b8dfac4860e 6e9df7119d93ba93371c317285688b49a40f56c9 +aa793f0e9d9d746eba8a7a60cb4981f7e24ce9691910350d7df9b9e94c7567b9 e01b107b4f77f8f98645adac0206a504f2d29d7c +aa83de8b0f4b0c6d26c97e1048eebff482698b79131cf68b0671eafc40444d08 8654e891d437bfac94db90e4c1f6878e0efd052e +aa8c472ac90d32654157b4a43e31135a9a864a3f02c2358c3b78316cf175b5fd 1cdb9a4f4f307b8d0a3439d6d496e7ffa0a19917 +aaa1b07f32e2a452b7c24d7068bd63f27349668ad1c834cca9d9a2abc2ce49b1 4260699b37a7a0cc6be231d232d424a858a7d111 +aaa6f15815044f9acc8541d8d28612affafc1cc820a084798ef762ac6978784d 6bdfcbc41317d86eda9bb191e87a57651e8c6245 +aad6240d16f18620120c221b902c9777d220fff8c5a0cbc8071ef6e826f6c630 4801a2389fa38676d2a42061f5e3841324667b10 +aafa750212c82433e5b7a0ade7048fa1951800536992c59f6d66c46b2337ba6b 3cd8b687d5dc8006a5eae9e9c4dac212e8df67d1 +ab2a5eb5541f5accca9d9491bf53002b131b547493d6c248c1f51628468b91ee 157999b26778bbe322028a30869648267bee7995 +ab4ca17ec21ddc7e0bb1bff660ed18d90053425adf7d85aa320454e873a18b75 c29a831c884ea240437bd2459e60ffb383dcd149 +abee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 181037049a54a1eb5fab404658a3a250b44335d7 +ac2a850fed51b1da02abb706f3da5768337aa2d49b414add21a668e2497ae125 2cd78883e494f23858067087893c38219aa4fe76 +ac2b785aef8cb5a9b563764be378ea45a50cf163d8bc37daea68fe2cabe064e8 6eef8dddafa405da3230fc1dbfbfc7ee8565fa26 +ac49410f64fad10760838866a40107573e42c86908c83ece433d64b7a8b57f7f 2f1c5d509ac5bffb3c62f710a1c2c542e126dfd1 +ac7908fb8ac8b6f3aec395f7b5a82f320ac634496b34c4e5534bb291bed1a8e2 c6039d8f24940f4bebcb7391e705b6b375f8fb93 +ac88849a26c126b03fc6fcb17cb23ec563e87a5f63b7afe800ad0f436128ce98 af292c99c6148d772af3315a1c74e83330e7ead7 +acc7061eeb4b06b989b9b95db3a726463793a54752bdaf978f2b643064e61650 37870a4c5009c19f3da47997b40b786f6f2f8b58 +ad00202dae3bd195b18e458e7f527e04135398a1d5f9aa3c25291803c26482de b6fca797357066296e2cd9bc9bdbbcd2489a67a4 +ad05c66a177f844f8239a1d186a1f803a4daa6286c959538838e222bc6337dc9 4ff1dd0992dd6baafdb5e166be6f9f23b59bdf87 +ad150ac016bb6e3d11d5d640927038619573205f34285a0270426b5d0d9171ca c867e4ff48cb00173ab50011a7cd593ab9d3905e +ad69d65326774c8e0f1a8fe7b218d2f4786db7657a5d6b03d8f43d8265fd3c44 3d35c193ff6508d92b3986a52c103b2c1fddea0f +ad90f638cb67720b20b904478471504acebacc7bb36e5dcad3e882acec496fed bed08a0b30b72a9d4aed7f1af8c8ca124e8d64b9 +adbab8789a2829bab3ae26bae696810557ec48f125e57e26e25b22a7f375a551 c405f734c2050e2e4ad3469d087368a29a98d27e +adced03f19d05aee4179e749bf666dbadbf031a12cd11796e4e463b0e2eba5ed 5ec2b329adcb74a8bdf99871f0f6c048fc90de70 +add26f5a369d9230fda1aee868bff357cfb63e39bbc21abcbe5e87a77dd70393 8e0a161f97b84d42c44757798dfc0449b1ad3c9a +adde54361f01131673d95e3f74e73b5b4645913941e061efc66bd5c85c40bb02 a0c0512a8bb09a7fc87c41528ba63083b44056fd +ade7d297ede7bb58008da582de1253f0a55cb76e82d1cd376f82ccf97f70bced cf7992bde17ce7a79cab5f0c1fcbe8a0108721ed +adf2fe0b01c0f20184cc5f4cafbaa7dd71f292a8f06ed0ae3690b21be95f661d 615cef56af79a5f5b39e4f337cc5d6e5e5c1759a +adfb7008e983eca01cd37bbe9717a22ab7f62bc731f2d5bae26fb99589628853 e33a4bd5f9681cae1b8956247dc73812a7406615 +ae235704494a6aa176dc2c4dad7705e40ca8932b44796287278bb70878206bb7 b92ae7738d06508c5fbfd1f2d08fb5190343ffc8 +ae29942a0032a27d0dd5dd802d5feebf1500cec3f37b9b0997070e9ade4df219 f6b73d281810e3ecb7e984ab7c951ba52b72c10c +ae52d4711e8115fa72fbb0397f995fd9163849ddd522582c1efee23a4371b846 bc95d2dc839d6993e4ed0a13966361fff93c270f +ae558ea7cc33669b88e4cba1d9448d5638f5ad5c6effc852948555f57f8321af 8baf75bedd0f29bcb61efc7c7c95761dabce5e63 +ae8542d347eead448e089ffb0c35067c2df35b7abfd9eec4f62eeb701c59b05b b7af25b7c9b2f436fd6a5cbabf9d974d6111f6d1 +aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 a8233120f6ad708f843d861ce2b7228ec4e3dec6 +af17bf05f3b3dbd780997fd54887b276c0c972aa0615ec4cf8da9bd960d560ec 1181cfdd77061b39dfcd72660eafcc1c578fef0b +af2ed32dc25c587ab2afe464a73b49a0c5454fa2bf12ae538a2165c373ac2de5 bab41e61c338ed174de4cad036da7a5edb40d28c +af34d66ddd3c768aae865ba6958dd9158ea5f5c47fbb5348a8e359f85f89cbef 9e4700a6033d42474c800cac6dc0095bebb14c76 +af4b69c54262883b42d42c72e8383a20843ca1521021808f73dad9216c5af6cf 6607b1c62646fb35b6f55f22c11a1aa14f0a1145 +af8cc9a93a75ef2e04ebd8aac5c62beb755ce4c1162d8c045ef578dcfe25ceb1 d9f106b9f6fe553c649cf682ed66b72567dcc367 +af90f5cacbfe4caeb5726627f9ac36e5bb49e8497b1d5428858cbe64a332cec0 f161ce12cbe824defc0e445bcfdbbb6f3d5050c6 +afcd6780d3255be3d03402a43209f1c5c32cdb3bcb23068b94e6e9247ad13e7c dcc1b764890f85180542055150c2eb8a7f3cb9f5 +afe1fad6f6b22eea530ff7b373d6b9b787b39792f720e6fcd0692ba6ef99e02f c0220fca67f48b8a5d4163d53b1486224be3a198 +b01b505b9db0c6fe12355a5dd4384184eb067779e23028ac2e1ab9a504bb1bf0 14be9ebaa30a1d6085e889eecaf2a24968eea24e +b01e2a8d4c07527e6492e7fad1f749dff75216d4f129e0d11ca5caf9ab6d8273 b60488e1d7564716dc2ae7ce078a415280bd7df6 +b0516a64349a18f3d4a48850359ab66ec681ee6575103523acf4fc9b5e201e08 739bfc1798bb97563e72c0491ccf8fdfecaf6a47 +b0675d24f637e6c2c05b09b88dd2169fa169c37dbfade733a5e0af0bb1e8080e 4386ee2acbcbbf1fdf06c75b91da3a9653075c6f +b06e3a0bfe758a68c5c6b9720f281b2526c19564179a19a0ba1844a45b089e9a 8ec389978cc56e25a6a5bdf6be993c7664e762b5 +b0a25f084f327104a3da545a926c6b89526d5399fdfec65d1accf43c8f197bf0 6e9ac9c85e1329debc18a30c520e59130d5b190e +b0a6aa2b450048e43155fd6d655cada03ba242a2c1b31438f93638a69e891727 94093ddb4164980ef98d78b1de318eb0ed74d933 +b0cb0a55f09a8192d882c14405fa0e8a366db3d07c17214f41614fa571566ff2 3e1d42b7d980e29595572e550d5ce58c0a34f15f +b0e890ff4d407faf502bc1eda5a18bb9f08f5761c2da4f3d6a6d563dd2f0b1e5 ffb55c532ccc1cb3c47eeeaac6c64240ab88fe29 +b1328b04eba6d6c573e7c7aa9eff201a654a1cd2c077ec9fdfad0499d259e7bf 2ca59d57a4451602a6db44da4b2d37a505a84698 +b167ee336fa10383d04670681af258d040347e6e1edc71d61af722cd19f1192e f2ddf1eecca39a307ab8544c2076a59441eaf5e0 +b185929191c7ff2f9df80b08b2698ec2811f3466cfd520aa4df2a8b777aea135 89b765b0e9f0b54f9dc85fa0a982774d07a935fa +b186cc0087e119842e1b7c70dc70f705d7da0013de7eb434a6f48dc299acec75 57b5df4e635d8324ca75b0dd33cb96271b426e23 +b195873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd 08b041783f40edfe12bb406c9c9a8a040177c125 +b1a61b0e46d4d5ff7268e381a6f7d32eee81e5c1304481e62ae5fba97870c960 9eebf8791489850089738a95773d2f3c1d56d89e +b1c6b80f177e1869b39215b2ee4089474d685459fbda1bc4936457567036812c 7e822f212370d60dc701504a5512544891f3ae05 +b1d6e5441c09075f9ee5aa32d8501acaa0c57f5812b316a74bd7911786dbb1b2 4915947ace431f2d1b4fe920d4cc446ca2388169 +b1d8511cbdce9fa2ff79665dc3ada50e6ea82b506cf11decd40539e6478b4458 c1b62b2eded035d22584c427487503335f519d4c +b21c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 db4df74a2fc340a0d0cb0cafc0db471fdfff1048 +b22a9ce429c6518de3a48dc441da4387fcec90fc88631499e61702ee5a8f8b30 345881abc471d0c65c8bb7e4cb3be10571cd32ee +b236af68cc7637d84a5cfa565e8b666c303570844c3d3dda6534a30b4824c352 eb2da5c7c3cbd270a1f945007ad098eadb4a68cd +b2732eaa1b3cb8942b40bf8da2ba51b735540dcb5605c29b694d7bf1cd500e9e cc15381ea2855139cb87d3a5d9aa64841f98c1fd +b2bc5b027b583a336347be589add47e0a89fecc19dd8a154b826c363af9a4345 da7ad841bb28fffb5546b529a00463206e47c8e1 +b2d355727ea29d217971a84e2a88527e0f6996015bcd01e4a2adb18910dc3aad fe6f9f29340241491470ad8296ce178ebcb428f4 +b30bc6949534a21693aeb43b8379df1b6dc621136a2c6c356e3f6bb86b9858f2 d570b36d8ea2d61450a40ca03c3cff9b144bd147 +b3364fd9c7680d53ca88929ade181defe8a00009e26e073ad7204fb7571aeca8 da8182721657446127a006281e0f1bb4219be952 +b34f4bbdec1daaa7d6e1e99aaa1e6cded1bec27170881f5c6527fffaf55adce7 1bb11859357114684a1a740e471edf1a7541b82a +b370899e23e1a0b5e50780586fe822e2e6e17dc03a2e56020cc1d11e072f5160 a9984a4e60291958a7cf0045758f47db3d214040 +b3836efc8cd5eb1c0ecc0d99df3644902cbccf9b6c7c38c3fc65900492cacb21 41c1bdce587d5c8b8ca03a5a8691ea3f09f16316 +b38a7a2ee69d55f021efa91caf59e23bccdaf6b8a9c3f83acd978aa177587537 bff873e9853ed99fed52c25f7ad29f78b27dcec2 +b38c89863825241eef7e7090bb11233910a0117436211183502d501ecc5b2879 e4e56117de8b3bd0bd899701da4712caee27c7d6 +b3ac32466d95d82432e7aa5a2080be9e3cf9b69f8620177053557d982a5f6eea 6909925086c86d40934c73e6d7a4b3886d5037c1 +b3fbad0e2e846628da5954b92c1c9b9bce24236f166547c5352503d7abe6984d d132e975594a1f22a5f3a480f5695e6001367b53 +b487428ddffd22b992094ae29527df9741cc33075a2ec0f4533bdf26459724ba 3316387b546b1d495ce646422e95dc209cd23705 +b4b7236050c279fcd2b6b05b6539c178614db05615eca1895ee1e9de98d73b44 a57d1866c26829f12095fd4f20f359e7552c52f9 +b4c3e22b042d111d7546f8d3bb4d3468236d28caf926732b8ef6c93eefbad39d 0cd5264e932f5dfc68959d11b5a3bb3a8714aa87 +b4ff5a6d6ac893413f20f16c9b3c999a5703e5e1238c50585ed32a64368a54d9 334fff1495c554746ca66f2359281b7de69f35be +b51d286a9549d2d2d6ee18aa839b2fedb8f3b4235bd763553a2a415548e7c81f 6e0fa05b58c140a42ef25dc74041e30f25772b2c +b5454cc2a66d713d5be85d5297def275ddd102817d96014c46f438814446e29e 5e98d798bcc9613cc34a083719c378d5c66bb9a2 +b61b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 5f34cd6e3285089647165983482cf90873d50940 +b6cff922b0be268a213f763aad8e357bf2f30e905ce7ee47d586eff02c5ad26a 1aaa4daefcdf508ae661e81131d810472fba488b +b6e8427e3afe1cf0095d0f5aeca0642c4fb12d4e529f62e8264b6c4db72f04b4 6fe7568fc3861c334cb008fd85d57d9647249ef5 +b71ee6c8837efa5b3ba3361f88c321d391ac05f41d5b2506cad39319e80716e4 c02d0b160b82ee72469c269f13de4c26a7ea09cb +b7238ffe9e20cb2e62107858809248620802f8f15c603594daace4681810bfca acf362a92101202f5f09c9b51db352be27b5bf7e +b73c6046e934b9a76e5b9c587c18a20b7a69852801d6b3517bafe09b78d1cec4 964c192fbc2997e871c6101cb63f69b3ec377b66 +b75cad007d473a24d06563276d7b254378f2a0935d231cd82b5332944f22ad1c 7b6e8067ec96acef9a4184b43210d583b6d2f99a +b790ebf3f307102c84da36abefd196078e569ec4279f9cba04bec0ed68ae93fa ffc359bfbb59bdfc5ca1fc95c9bdc618f89dd8d7 +b7bbec7e6e8cc5a640d966739b0c7ff09f5710f534b278ddda5a5edd554dbac1 d42e47121844049cea15900ad772f51164397573 +b7e7455bb13e40eb23c5521f75bd912da55c7cc4882f62cb1a5ab0780f04faf8 a732c71d3e34cd444e9e0386b797207bc116ca42 +b7f1e115ee187338ff5720b118395dafd6087ee4ebbd63883bcb4c239cc1ec2d a59b93fe881d5983360984cc2f81b4d12d306d8a +b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 9fd738e8f7967c078dceed8190330fc8648ee56a +b88071883c4741b0f044dd83f33c8b7fd514a6534f212aff1c00efbd96cb0220 7f11132869231c5461b911c054577d101cff4b1b +b884efcbb7ccfbdb587e2049b9b28a7d025d3a1a5f9c1d7708f39a2a2431fe89 04133b0608f824a5d662b85c866b2e84244ec0c9 +b89ca9872ffc92ed33fbf3e18f6acf5f9ac58c70a7408137a6f042b7ced845f7 40e1af83bd6b13b718c52673d2ad68edf54b6d6f +b9134c331629e9cb29d1bbc03904d911a942b451e087543fc16deb0116391297 6fc72e46de3df0c3842dab302bbacf697a63abab +b96f8b46286c8c2a0e73d2e320abf35334e7821e561a888f85db612b2871a1d1 f4113b8f6c796edfd95d2d178dd27140e8d5eb40 +b98e3de756c625603d536f742b69bf11955d439631f286712927f5975d560e1f d2ef83fcdc0c9cad633e7b654ab789d17f583f30 +b9fa227a38b8d66e3c2acc8a463ea37768496b746d370b95c4803505fb79b84e ff4fd6b1cde132c6cc6278ad7873d7047c897d2f +ba038509caf46d121547a01557da21517aace95267ee6ae54bb7db1776fb5825 ccd7ccdd6a61f941642d75c3870d82cdea9e6fa6 +ba0a8d2454aefb8f2723fb6fa5a1424439b63bf2f6f47d575aee73a76a542a73 b4b1f3118c4afc6034b5f99eddd18f7dbf15e5d5 +ba0dc4a1787f9159a174b1e010018af3ad2f5f84c8e8eab98f67540663ae82b9 fe4db4d4c93b5fc5d85aab2198393dcfdfd390a3 +ba312594582a5a746b8fe46d639f8db0314522ead4339ee6b7299802443ba5c0 d9a9eb65ed8db7f1200aa017e5ea2204266e7ae4 +ba3e0a5d754cb8fb417f0b8826d943fce3007ea5fa332abca0eaf31ceb99caab 41cb5ab070140451804663d84b8190d1c5d546cc +bb04bb109db80e12067bb064a5e3eb34c5090e41b4ea8f289c2542efd21fd8a2 662a69f7b8260cdd2461918f55353740451b0ae3 +bb5497a9ce810703e014a2ac6fa1eaf22625ab103c7d141ef40343fbd9db2a71 89442107982a1e968f643808a9e4c9227c1cba2e +bb5d090bb1914554341daf6c1dd6fe4e5c25e466818e5012ebae812392b58934 bc2c876e099e4a12b7b28779abba186216355c53 +bb680fba7ce88de98d4881df75bbc7921b97102a8c67ea9d9b45baf765a4c354 0a420998aa494c4b9152041bf5d8ebb80a2c4cb9 +bb6a768c5f4888cb5f37b641ae0475c1e8806f53e1e55acf6befc7ca727a170e d1487fd5790bffdaa06c181d53cb966a4521e899 +bba3e6952c7a791c03cb65d4919df3ad767346cde441854153327e24a829c1d0 860bc8dfd43318cc0513e98d4696df7378b6077c +bbe6aae28af3c8f82c5f1d6cf882f4eda9165750e08de45e9796134a294bf83d e074873b8c02e2a3d3beef03dd3c8ee02cf3ce9e +bc1b9a106a7ea9414b5149bc9a25a49df09cbbd91a99e5ffd53f52462792e28d 5abe9edb69b20ea386597b062e94f2679cb81fc6 +bc3c9e7c3339eec5a01dbac0a679b06e04124c4f51c79fbc16ea8a68323c0654 fbbfdf9f13e92da2dc31b56081302f09fdb62e49 +bca7f0c01fb672c05f86199908ae2f853f58f0adffb9b97b897b37c2b5633cf4 0cc8c5d79ad42f4673374b0e9cb00c3777e55a8b +bcbb54aab5ec52d387c70baaceb1ae313b312d354319b95c58b59d5140bef0fe bc584bb33674be3b3925c7bbc129f1f53af21869 +bcbc6e0586bfa74313dcd57a61c4e958abc0ac7abb3be0f2d82d0d08a3d5b357 755a4f75d2184b2ad4ef107932c86c7eecd0806d +bcc4fa242e55c5e08f64900407dca1cf2451806830905be616f339bf7a5580aa 50298f44a45eda3a29dae82dbe911b5aa176ac07 +bce08cb2060cdbba7216cdee466762f3cc8e3dd655387e5f5092a748ead67f6d c3ffa781d527d08ddd3cf626ade4685fadce498c +bce2be789b7c5f0d236cb597083143d261c705c2a66a88f4ed547ed9e2065793 87f7f37296ff41d6f2c8603d68f159cdabd4510d +bd15edba8822cf76e60aec16a0edca6b464f22bedb2f9d55078f51cfc7134405 9ddea2008d33878aded26b0c64ae82ef6def49b4 +bd32ba8cf33cd3049b5dbb3c18c0b0478a52389cfcddc7e7b80f66577dd3ad0e 6524d538430cad9215962d6d01b078afd7720bc6 +bd531ed2f7d5971c642a86f8fbd5347e3b85e2619c891ecd4bcb4e23976f35b4 0bc152bdf2707576e6ef9331189607c89f9ef8a1 +bd69bb8de277fcd70b2accb62a064eacd6ad2e01817188f5577eae25cee3a35b ba6f870d2cccbb6439c43979a9fdfa72c05b1a73 +bda24eb65236b353a3c5ce73585fca46ac4339a386a463afd3e28f69fcae213d 8c7af5e16d87c12dee61f9aaa6cfd06ed93a08ea +bdc530e0b98dd736cd812408eeed9aa0d393bbd0630b355eb7601e61f0dbc7c4 90f9ff6755330b685feff6c3d81782ee3592ab04 +bdc6e8229c3beab1f6fb0439687b325467e2a8fcd6267373881c429f2f9a3f78 4711d372e66dfac8218c4d5eafcf03dbdd4706ef +bdddc903f4cb49c257ce31b6e651349f9808d82c320223c339a66a03a9f7829a ab415d59cdf8cd11da6d5281c75423691c0a34e4 +bdf2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 3697d64be941a53d4ae8f6a271e4e3fa56b022cc +be173dd892e4502149db328c9372962a08ccfe705a22fbfc89190dd52ac9f939 2a6d97c7907f685ae4b18d31d2ef6ec7099298f6 +be218dbc2fc82105b177a9a07b4e0f615ead9b9be02b13b2a239265812c1e739 8c1460102ab097ef014291e939693cc38daa7e98 +be3a95fe895bbfaa243ae46c89573d9836914465791d41ef6404c14453ad9e2f c51355c1972fbaf3cbb5c7be21939d2f4445e9bd +be7648b598b8c830353f3d8a9da3b434ab4b636edd7c5755171912682061e943 e5d1faefab1bb51f3d0fff2d5e2cfe4fe96a9c22 +be954c7dd99bb22f2730f3c65b8a6ae9d1940cb909cc89e6d83de1aa5ded6946 690624bdfc9dde7d14609ca798b61bbf5fc9e9c1 +bee70212dae887b4181f4c256a008a0509792568c82ce6f78ea5170dc5141b82 58b932645c948010c10a9edb2e7f1f51fc165230 +bf148c977af56b2c4f132adeb987da6eb63b309d7e1755889bd8c17cc9e28520 ecb100a9c8feb1d3bcdd6e13ebd4097eae84be9a +bf278d619d1bd8cb9e47d70df1929ff019a1f6c4d8bbe070628213778238551c 1f798df229a70aaa4ee221ecc0e24025ad92ed9a +bf37e4ecb48fa5813c8c587c13b1dbf65c9de2278ca1093b02d241bd148aa36b bb2bad2a2f6cf5dca3d3157b68112ef9cd0c5817 +bf409f1aa76256282ebf1a7cc6c9f4220be9ffc47b2cc42248fcc5cbb67bce1f 30c62a2d5a8d644f1311d4f7fe3f6a788e4c8188 +bf543f7bbd00b73f6ab1cd8203c5279ee3c319705580525916a86f2916a5cbe2 a0d9ac96c359e218d35b6faff16e63ff6271f1bc +bf575bb55d3a86838a50d8c74f46cb4f00515f36e639a1c169ade92eb7ed5822 82324ac1a5ec79069877ed5d807c87762a16ed9d +bf66badfda7b5d2157db65c5310cfdc4e904d7d5da57ac5abe17542de612f856 8f0c4b543f4bb6eb1518ecfc3d4699e43108d393 +bfa3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 2d59075e0681f540482d4f6223a68e0fef790bc7 +bfb8433faf78ecf75ed9fc3bd8a717827bc186db50e525ec46ad318d6182f91a 0a7ee40d31baff4e6d9b302446547e53bdd08b64 +bfbe326cc9d9fd4dc3904de4c9fb919194f3215baff612b6d3f403e2522fe163 8382cd353101c0963d5f401bbbeab5f6e0248f07 +bfc0ee6fe04854c11011539f38cc6b9b73e0c445bac2008de2fb877123efc2e3 e044baa468a1c74f9f9da36805445f6888358b49 +bfcc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 5d0f8f7891e872d284beef38254882dc879b2602 +bfde5e9939f87db0b49bb0ad5303c14d555a32b2db03dc63218af87fc9ae7cbd d7a09674532ffc0bda73e7c6e028bb78120c85e6 +c0011465109f2622a12479cb68d0117547513d48254a74c1a905ee88943263c2 e8dc745f5603c43ab9d69e790ba6d600f24d108d +c06ee60e4559ac134deab08997476c059b4baf28973f75ac00310f9c0c0df532 e8abd2f25c5cfb7e6f296699f1bc120a78bcb7ba +c07142deecd175549344fbf31f3987ff54e6fdd013b15d502e83f67edee4be4c 67df18d487d28edf3fbd965836f212f7edd2fa6c +c09c5282575731a965aa96bc17770d001552a22577cd80110737c2889a2b4833 4b09231a1e78cfc8e19477c2302ab80b689cb8cf +c0abe8f37fbbea90e1ff3d571c86ea4c6fadfa7f7f12a4a712c821b065f2b0a5 a0a6eea81880dcc9841f68766351df223be95f1c +c0b3f002ab7ed5b861ba27d5566f8d54ce86ae8e3f0d7039eebf52941a164e0a 0867c7b57704e5c98cbf67d46df03dfd549cb0b0 +c0c38ad9820923073ff986beaedb4daf3217b3028e48622bca80411442ef6047 629bac23f626ff2f0aff71580b3f46742643b14c +c0f1323124d0f0a45ad1511ff43041f766fe110e56d0b063d41deaa9f443b61f 5fac2a68ae5bcead128415169a68fc21d9e0f038 +c0f85283375a304cb98d2b47d3b0456a10b934bf1f89bc3f80d6c4df2087460d bcc85e9ef60749eb8a4cd9db1c9f7b3b974ff407 +c11677e589c7d737baef01be425cd0c2912b78f6e426f1750a3b7d5cfdb123ee e45535849cb7187e22c9fd11d14e0eb37f5d7dc8 +c123679643c715765e9fe6859d5a5eece56404b03f29266eea7c0e83ae14263a 6d646a4ddbd3c0fa824b193aa83b48b38b48848f +c13a073132718d2674e3aa4bc56a039582e61cedc9e178ef9862588a7f8c7675 5cae6c25279bdd525124b7686d67072059bb0fd5 +c15299caeb002894ed0743a79dfd1cc520d3aa71a2a84e377ed2fd7827096969 1b61137f9a2d6f90f46ea3a7fa7b89b8f839b202 +c159593092a4a8e5c4dfd9ca42fbc98c67ef75060f87b92c4bc677b809be0a80 ca3939e682a3198a3d18f42b7fbf84823312dc61 +c1599569b3f7b5ab531371b6c762c9d578a794e6289a1943f6e6e45ca02ea05d 00f43bfc81fc4ee3a1f92d56808aacfc8089766a +c194ab25a95d8b7d4897515a6fb62a723e809afd7c1039b7a50fcda3c2edb2db 475fe13a56409b64b9ebbcfa1a0e77b27d21d189 +c1f503e2869f51ae5487b9c89dc93892aa92e58dff2cdbf19348056997a17a8d 94c3c71da52ca3d4761c4e9041b384d9bc75ad9b +c223ddc0bf50e860fd0e85b9b4d47b74409106098826fe330a9d98f2e3a8ba7d 1ae06d0bcc8ac256710c81ba92a16a644edbf456 +c223f1b579bad18635efdeffa7a8ff40567d03fa427e08bb90d9878f958d8021 deb106bfd2d36ecf9f0079224c12022201a39ad1 +c23068515ad0d427ea509d3b0a3b2a6c5d6ab433d6531a10da6b7d63ca0d3594 8a3653350f78e3e8e91f2e14747d6dca4b435d8a +c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b25fa35b38051e4ae45d4222e795f9df2e43f1d1 +c259153848cb0a2d858dbcbf7b4f40546f2fb60c31421f9726da11953cfea9eb 8997caa24765077a3c3b70deb995819488bceb90 +c268fbe2c4169776699a64bf021f1767ca74c21970090388777465437910c3cd 5ee2fe777c41d9ad9e7eb9fece56fe21f830c5cd +c284394baf0418c32e379cb3bcd5caf190e83e7a8b5056789d800f27be6462aa c5c58a0dad7a0cf18859f29326a0b7a44f23e4ca +c28e313f349b558f23f9b4c7d209d5f0faa3ad79edb8260fb3fb154e5f578905 22bef3bc97a19b18125656bcd77b517680168970 +c2b1f6e286be2959e3725a1d890e178cda1c31116467d5cc0c799825b17c8d74 6a5c2bc91cc42f38753da59a3291a6d9bad0c852 +c2b535bfc3501f0b4e179d5d6f0e2cea613940fa3813be5923db7e71e190849f e00e46abe4c542e17c8bc83d72cf5be8018d7b0e +c2c43938f901a6206679cf488e48f38742c36dd7bee0e027fc298093b88d9cf2 b3106cd34a7b69d2d3b3913415423bb2c45701f2 +c3055d62611a3247b1863e5b5955ebd263d8b8e3367d8efe283bfe0462b4db1d 19d13c65e11f45c3be6666c6c4c9732c6f4ab40a +c30d06fd49797e3135652d654db0de122dd83f8400df1c7a0e95ca3720defb0d c073337a4dd7276931b4b3fdbc3f0040e9441793 +c31ec989f2f75e339b9b7b106d5c1f5386197bd4bb16140fa8e0305e03ced1d7 5b7487bee63e7f5cb6ea1d9090d52ae631296cd8 +c339c838d5d21d9c6c6e4b7efede56c1580e7e957b5da395cee2f689f108709c d3cf2a0e30b4d3ab11340efb3d9af75e61b7de8b +c3f4fedca384b7225c7bbecd31c52d6158b1ee4872d0a85fce2d44ad357a6b3c 581dc350d5e699a9428caaf6a59fca78709f4bbe +c436565f09dca3e9556afa41fcc79ecb57c448a462d6c310df86b8b35d5fb604 43bb43402ea3fdb9ed6b4aa82876c38f46d1eb72 +c494dee1d03eddaa9eb923ea640f07f660eecb9661499495899c1601b885c2cc 81d3ab652c6af3483f72ed93b089edb999e7d140 +c4b306fe1f9564616cf048af4e566ea7b404ad069c972ef433d21469dd93056e 4caa8962a6af9fac72ab81afb03779bc3acff910 +c4fb0a710b3cafe7f8f43319d72d308a678c12cebf0682860b1035352cb5d4cc 2ba363e5885997c504921f8c8f7278a97fbe753a +c51ca339b4668e4ff289c3e9ed3f6c11de42c85e2c5491fcecdad93432a2b13d b8fce12b6878b56b0d7be4ce7123b4feef44c2c3 +c51eb1e41d61d89ddebdd78357baaec018226bff72a4c9296934b1c48fd785f7 f1b16987ec81874cb9cc3d6a2e7d533c950fa68f +c52bf4d013448d7c53a6598f85de0cfdbd2eb110a058974534ffc27c174a9ff0 92142d22d55a2d449d5c563f6e72d827512cdd49 +c5446a46d4c6637c2f45ce4fa113c64ced344a4eaccd3ecbf2107a85fbe18fd8 47015c6bbd6b6736985a562bf227a989c6340df8 +c564b89940661e3223cd7ded73de0206cfc21827bc0b9bc44e95d411d1df1b0e 01768b00b6b8cf1f5e34f7f416e0d506497cfec8 +c57f2bab01f9798f75e61c27f55a91c743b8d23075728699e84b9280dcaaf900 2812156aaff1a1d7785d56809e8cc6643083ac4c +c5afc2ee84f7b25ef38420d60f97b8906c178cfa90497d9f5ac5d1825b0e0cb3 f76c2592b57baa77423bb382d2e86898992d883e +c5dd7dbd64522fc4b9b92c6a56065eba728d026a8d9274c30ae26cca30525d46 b38ab8c4a1c9e346c9520ff9377be3ca45b62f23 +c5fa0af1a59da387fa8082d801573bdb342bdd59346f7599b5f8e9697dc1f076 89039682651474c6e2bf9abcc02cb71897f8b4e1 +c64531faf49ed50c4fb19066a734fd236e6bfe093efd59596dd7d802fd311d71 02e4e5bb290f13ce81d239c1d590621e2d146671 +c67a633f4eb848ff63a1941b3ca756dd08b5226684821768d918e0d839ccc4ee 833ae912e8d5bd6309a2ebab027b9ce85253587a +c67e84e246ad6aefab06f12ef980425062b46b04a66efe482927dd937b5b76f5 eeeb57b574aa97501bd7f477330a2bca8d1bdfe3 +c6bb20cd7be8c9ff8b9cd6246f5dd2928d2428b6a0b2e38e7012e565bf7d9bae c6ebb4a9404e6cb7ed09f0d775c093f33a82f9b8 +c6e7cde92dc4e7be645bf8ec2b6d2ae9953f7c9ae934cea12fb087a9673629be 64883249d3cbf1db4523d95beceaf0f9f8e6485c +c72158b0050e8c9fb81af7d4265c0cdc389cae3cf235232051eadd50f4c1f931 c4c199245f930c01729a0d7c60dc05d9dfc5f53b +c733169129f390cf971099f88fec9eea3e23de7bedb2c72a0599010d6f9030df 6018dbfa702b818590ae682bf9bbede716ef290e +c76564a8a44e38ab10e01f08b5064779775d050848ca85b41ef2b58cd07fb661 a1c96890e1b1fa314c4b4a3746c86a31e4a9d78b +c76e3695d0e5e27713dc9b34d2e93cbe8a3c780f0c829ebe2fbbc9561fe2b0af 621c87ce34d888782dc907b62eece21f94b951dd +c7aa36af51e9e39744a3d71a524f3228eb0ed8c7816cd863c81daa83bc33394b ecd016dbd912f8176bf9d8ade8b896e0e200ddab +c7b0a7eae7a77dd7a50c57b9221b7955c083c8aa2401b20ab7db4738d93faf88 7b5d9df4c3cff229a132e5684f5e5e7bf6219463 +c7c775e8d426131b0ccf13245977f948f9e6f92f11bcdc748f2e005e8662eb84 84f7ad61f33939cd7bf04d8db04cc9ae7cecd8ed +c7ff2786a6ce3a0531eb2f4ed36456392a5bfe79b2b53e8f55ff987b31058eb1 1e5dd57214dbec1b166c881c1c44c8930923da17 +c85e35eec23dea4089aee7a2dc7f6d937ad7e13c66bdbd7eef37bd6336418609 b10489944b9ead17427551759d180d10203e06ba +c87c2cf84057545f38b55aba1b610af68236dbe0dcd196a81f69a050489572c1 088171c4dcffec240af3df4cfb03580d5bbc2a6e +c9158067646a4f730de9e833b1c57412e5fdbac9391f1d374eacbef4d5906f48 f269af47f67816813da4b4a06935bec131ad7155 +c95f52be90f0078415cd38052e756f4937c8d98dd5404b2833e7d1505744d6dd 89525c4620a1065dd47fd7d3960cc560a289d3ae +c9a1e208a73a83131879e9a986b05691ff7b082a45f79bd840f1b87e3bd34948 7335ffc31f110ce77ba291719841231921dcb17b +c9ae9e3895579effbbee5aa744a268beacd3be882e7306a8361eaffd7de9d89c c16281e3250d7103ad6149960c6918b2ffa459ff +c9dc53358a0d83bee1caae40ee81d752abf4962a9f206702e24a447b766b5bd7 fdbec189efb657c8325962b494875987881a356b +c9ef872fd3e8065a122b989550e08b24e38c91b6598be9d4e8b13cd17f55067f b74eefdaa96e4a781d649d043524fe7620aa7e86 +ca1bf49cb84d97e4e068bb833a4f2f151401bffcd3aad55fdaf496aca3cf7001 1ddf7a3bc63dd2ffbd9438c3b25881de9ac0bff3 +ca2b746be39b1d1ae42925727ddfdc75ba08bc650657647da081931ed1a905fd ce9eddc98909836d71b0cbacbc05951b90880964 +ca31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 9f13f7d0a9402c681f91dc590cf7b5470e6a77d2 +ca3660522468fd1d803bbf34a9c1685a0cbdd1b923528d69e6103955b03d749b 784536a2a4cb6805d0f64821337ea0b4b20daf0a +ca5237cc6b66c598930504f24af69c3011786d0d9aa5d5da2219f2f10bdde3fe 22237f6c06ff14efd3c233debc41b91c3df29514 +ca72a5c3e0c926b9e8abb95d8cd4110646dfd0dc5f2b283d48b781cbe7ac80e3 7b592ecfb272916e95ec2180a02361f23ed1bb37 +ca9468483c7625c1ec1fc8e19a3a2cc3697d9caa3c4d9df9e51d80791658d4ce 70aab459aa2df8f13b828a06976969ba83612f36 +cacc70435c5fd40c4e75ac083c898a5f35105b072d3863bab571cc63b424cdf0 6b7d1f7996feac885365b05637efc5a4e40a0e5f +cb1bb869adbd4a5bf2861b40afacd0f89906ed7f2d2ff4ceefec444f0166373c 0985c00bcf2bc8403f5d0c4957f3c2c8bc2808b4 +cb252a39ce30cd7b6859222db23553977f7805004501de9bf5ce2b5cb05bee7f e25bc23dbed506f090c7b7794568171d992785d0 +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 5b5b025afb0b4c913b4c338a42934a3863bf3644 +cbdba7ee4f46c2afb421f33275c78d6bef60194f81571e5f9b027416872d1efa 7f5dd37769557fb8ce6eb0f82dbca7394eb94fcc +cc360fbcb49b10d8e9b6c5b95564133fd0ca52489f158e37422fc9d6c09a10fb 61650ac5909362f425cb2c1056cbae080c594b24 +cc3d272d457c7e26c5d611923841511a1766bcd58e5be66433698627e6fb3f9d 90bbaa9a809c3a768d873a9cc7d52b4f3bf3d1b9 +cc8a9debdfda8ea2c6c7ff5e0c9b5d63cc23455e53a1653d42f58c1ad34c8db2 cedb2a22e6914c3bbbed90bbedf8fd2095bf5a7d +cc9e079a90406c7642c6177117674d5e542b08b2db88464291eab80ceefd84ea 19970ce5d4f01cf1e0c540623e7ca9cd6e0d9c7e +cc9f9094162658c03f18809a18b701a42499695da0c257c9e85c33abbf55b43f 1137d90e655031d2c56e925d51af666d0eb0b949 +cca7b385bd43a402abd3527290d1acd5f68bcee3f331bafdc389a2b4d1cee92b 48bef82ec4dd52cd440661294e511e4ec183988e +ccafd013fd2ea60aab89c7548df3ef5ec8ec2e7bfb8c1bd50236790fce491c3c 8d330c18a62adc01b16cdd3cf19fde92ef0dafba +ccb5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f d6c93164c249c8000205dd4ec5cbca1b516d487f +cce687695f024952191b9a882f65d6659e2bf75ff6d70311c35d1a17a7a72be3 028ef0de72da1ad4d1b2ee4a125ede81e3f2ebed +cd0eac51035ebff474d4995e000cbf329bb0793da89b81dabab277ee3977140a 6acffa8eb2a20e3391b5f64c961d7176315f1c1f +cd179a62d181b98a8b7e7dbbeae518694d9cb6314a7ed06c67c5c44c64a6bf17 1764376034ce4f4c899f141c121e1be9167d1e83 +cd9398b37060a3710a0ea0125ea12e0fbfff1ad1f5a835ea880ebab058545bee 0428026e2169038ce215dc7a616cf2f85d9833ba +ce00531bf1b7ed6c57f8dd8a02fd86e7f9e961019962d5ad5093fafb7d851888 d74fb65670afa5bd44b5d9b996a2dc8e409d1d92 +ce354c4274883074fbfc8f1db21fd783e76450619fe4c09ccb8234f308c9ca14 095a3d15445daaad79df8ea9edb4c7b78ba2cfa6 +ce3ac8622b4d6f466e837b0c7cff550d040be27d80b941950b3f5515ad66cfcf 523f154de39d4da383a9e790d513d111a68b7c51 +ce55f9f5ab1d799a9ffaa839539af196d13f35677b3d0761b0fe034e764f8d07 1093c8ff4cb78fcf5f79dbbeedcb6e824bd4e253 +ce601c82543fb1fd705d7c45deceabca8dfcd7b1f156aa4cce6a8ad1efe7d61a efaa56ae9705f9dbc24ff0b27daff60c382efb9a +ce82899d44732510ed59ffdf65793e8b87aba085bbe791592648c2e54149e31c 66a0d3e080b950bd021b41e88344b320ff6cd788 +cea0392913fe99400ea093a60cc9bfdf9bbf5595c3b431c19e55e2fc6817edf2 59b80d2729ddb3883b6033165586e4a8ba206e1b +cea8d32b6932211a24dda86e4f78a7ae9ab96f7473e401a644fd050f3cf98722 238e54bcfff45d477a17cc5a0f51f8ee4bc68bad +cf03eedf2689e76a91a1a230b386e6c9d74167205fe089f44062a96bf7470e89 770de6abbf0bb31fb200f0ea0f86ba2cdafda441 +cf096f21a02aa07d39587714d828e04cd237457a026545866f3fe520ec55646b 3e9e69098af2014a0c3fe9e46cddcb5365dd538b +cf1d995805102eaa9b331c1f6175a3bc900d02712c0136d5eb4994acd628955d 0856dd76baf3d609acb5ffe3b13753cd5a046482 +cf21a1ff89546dc52c6a7d5fcb6d95bdde4210fca4b6fe3e7e61945c09c37ab8 840fb8b7cb13069c2c5f691beb30c8039b384526 +cf329ab6c0737e02eeb28014efc5968aeb023de5ac3bc00f18b254deb46deb0f d6694db21c2f0a7e111ea1b0d9686cadfbd2c7b8 +cf8449d51d5dd28842df865aa457d144e93f12aa1491e553137780ee78f12cc6 1fec05920387b516347793c23c32667b08208fd9 +cf84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 d07b0f9a8c89f1d9e74dc4fce6421dec5ef8a659 +cf8e9045fd1d957f8010c75d60039bcab5510d34cd0d74ee63d3e5d35c135b6d 28f9832928c52e08c7db5a0d31fde054f51fc475 +cf9d92824b6450da8a2dc21ffe27b92d49b9f4fe7625aef81eb2ffc9023d2d25 60b2b64f87b2e7956a2a1b5cbc5b08ace8140703 +cfaeef6c51a5ff131946932d81b5d0adf3ea351c12c69d11a6ea24c579063914 93bf51fc98691be66471275974cf020974864199 +cfd1c700cc165ffae0f209da9e257bf5a81073b72f99c65b9229ffb7863ce861 54bdf67864a5d9dc16fc548f2748462b3fb63697 +cfdd565f4cbc315760c287d57714852e1a4894eef9c715332fd556f2e114a9f1 bf2fe2acca17d13356ce802ba9dc8343f710dfb7 +d045e845cde8405d26b094b960aea32e0ac01d5822b9e9bed9a62e036e453a1c 6e19d89f34fc5516f5c01542ab0050bf127fabd1 +d04809ed41a6c0d0b713efd6d7e586a7a05287929a296a4b963938c7c01cc317 c545d2d17706399afcf4482163359b03b485fa7c +d048ba2ef4fafa502a44cbc1a50cd58359b9bc243b84a08f541a08ca5f621137 a93f42a5b5e9de40fa645a9ff1e276a021c9542b +d06600e96b3e787b0487b24a3a1ebc255fce0bac6f59d24fcd84814628032faf 56d0888fe6c6144ff623eecb768013569e9458dc +d0665f4f91544ffe89e66d84e7c24b6d87186fbbe3866bdefc5027d8068f1fa3 61950787a1b26ddd5e6f28ccfb381b91c7cf5236 +d088ed0704b46349ee0f8758cb05f1ca5fae4ef74383034d29ecd87b010f6c10 dd95fb53d92f45a9901b5b5e983760a850d98850 +d09b74a21594a6ea4388732a10b7d1d73eae0f94fe3d5f4855fc80444d885372 0c01d80a09b0908856d5494d3c7ac7e6d22f1126 +d0c992aae9cde855b17ac826234a73255ecb09534cdcfa633d90640f6a4324d9 affd84ed8ec7ce67612fe3c12a80f8164b101f6a +d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d 53fc32d17276939fc79ed05badaef2db09990016 +d19c2efd2154cd79d3b430619d99438464b038da8540cf407f76119204ab0782 5a646197ed0c131e5326b5fcd95ad88a1fa3f2de +d1a49a45a5f109805fbf478a95715b528644d0e0f10b03dd2dacb4261dbe0094 28cdde6f9faf5a78c048dbc17259f89dd4b26e29 +d1d60af9799c7be57ab4d80713420c9038e360c0164a540247614916996a4af5 3bf9a46136794395a845084011283d07ebc3e958 +d1ddefb4e0093d5a1626d9a1b6757ba2b63a062fbdf2df846f8ed602f2af6166 89b6f61f7b4d3ac809de9427927a8cd515b4bc1e +d1e8c4b8fbda2e1696c9b9ff4e0aa9ed3b7caee2017c01c06525d08e982e2c3b bc23042895607cd8127e5de36f3d330cf20edb57 +d1f527040a42190f2005017fd900e895a77f9f8849deb117f24450a437c27527 749a91d742b7535e1a746ae6708350705e270748 +d1fae456ffe8eac24049a507d590380f8b9e44593bc33e465fcf94be9cc88cee 89cadd27f3c2f56f5c943e55416dab3ee2d4fb40 +d217cd3b30193bf232ef480c7338f40d2abe46d5c104b485edb6e5997e4606cf 383d52d47751e52c11b097d54e14b436bd41ddd8 +d21854ac4b6ae500514b5e6d7874258bb86400934d411ed47345853edc50bdf4 ab3f234e5f33426172ecead8d964b927bb281850 +d252ef75129500a3f78f16cabc6e0a824d4c1bc3e86b9e0a18bad7d389353cc6 7d685c7221b01af31c9808145ccd5a356dc67f27 +d279a299cec8dc4fcfcf8f6bd4c3ec5769628693a3d459f1dde581754c3b2745 d65577e1580cc68402df5827fd9ab4154edc0fe6 +d297d0f4a84ed8d5cbeac8e262906504d1238d59e9bb0adc45699eaf1da67372 199447c2a54e662c9db370c9a6c89219a32f9fc3 +d29c10f22acb667743faf888201a16d5a52dfdd3168c434bc7b6418d24f0bc87 2d38f94e73d3a6df5d650ddc6835d75498437d22 +d2ab425d6092770366bc3dff5276e3a869221bc7b6d22e99c089d556e7eb8331 d01f7573ac34c2f502bd1cf18cde73480c741151 +d36979c8da3118ed133cc999f0d4bb1aac029f59b2a6975893f41ed2d5c97342 a73891d7c5aab19750b0f1999120759e6ab0eb32 +d37ab9a95d602c7979d3dfae35fca327b313836f11e8511e1f29dd3eebe0e5aa 3d1f0e5811ec9f56650e70f8b27acaba9f34e602 +d3834b1c2da88ed1e98a742f7e8f326cd53ab464cbc726887d9cb019eed6ebc2 1a895dd787a5699c21d7925e9cdffa66f23605c4 +d3c2cc39665ee7d8e3f16069e0e27f35813e27c802d5a98be106dda765effd1d 3f541ffa6803066aa2db492a8229e0b35b5862c3 +d3cc02106ea9b78cc5d1ebf609a4931036ae3ff283ced382252ee713ddd5417b 5690f02e87e4fd31dfa9fd7c9c01aba03603cde8 +d3e3ade60c7ad970e4ee6eeab5fded32ee932e29d6dcb3656d7ed3bc9cfbe3ff bc403249eeeb37ce4cf73dc66711c13c5d19639e +d3fa679ce39641a538cc30576fd8980999a6edbebfb8a4ad187dd406e2dc4156 bc874e116fb4e785081344c2ae39aed3bd072288 +d3faee8d75868598e59a88279f0509327844800b54e51fa96283d3c8e3e7578f 6533aadc21270052d8d05835b1e30d8b13a2f164 +d451619d5bee5af825ded81f99b3862ae60fe8b182ff10b72db8d005c173dd6d a7335c5170f4a963c8d67782fa35222d03d8a16b +d455043371b8730cc74f280b64e25183233fdd330acf54ff76526861d513bda5 f92446126451b27205551041c92f5f7f84bf6d99 +d4698b848903dbdef9f5ffcc0496b1c82bcff777107819638591bc5c93fa2942 dba81bc591c332550be284f9414350861b6b066a +d46a8a40c5bba0b053951a958ab021f19eedf8fa4e5a75fe1927d33ca498c973 a920633902d32a6fcba87c729b14e08341bfa097 +d47674eaf38c4547b4a490e5fcfa7d68ca91e8aeed2386942daf07bd1f96ca97 f29249340c11b069e46b70fc145c1d7fbe213b94 +d4923d7b828b897cc6628e6e026fc956a347002f62e1f6f52c022c2c9c664954 418382dff1ffb8bdfba833f4d8bbcde58b1e7f47 +d4fab9558c0aae0a9010ac44434c891492e63358a30960b40e48b0d0e5f70694 9a9e5abd7e7d2ce46fd6dff590360da875b81247 +d4fb1e12bb875235a16a5037ebaa06cca35204c1fa89c9abff02282beb74820b 9655ff12d31716c9049912eb6378a305346652c4 +d4ff08d0ea45b6d8eb47fafd430e2496b132b2a0617b6cd77809eab2612f9823 eab36c05f0ca151dc5732210223d0abc9e9ab321 +d509bbc6e4420c5d0b833045f466b02c02922bc4bee55f91d4b6751eb1a87074 061605020c8f212d696a2a3d28e20c7091c09443 +d509fa76ff5944e25f48c2476736b6239a53f0463cba6ebc488464d087951951 100746511cc45c9f1ad6721c4ef5be49222fee4d +d5473cb18ca962ea72ddc29df047c3fc1aba13e5cef68e600f5563135730b357 7e02841efbb3d464e61bd4dee8d6031afccc6a70 +d58aa1f4d8c35426d90279e0a0b81669fbe25bd200f969fe75440f8022f98ec7 b81dd80e8cb77046b6196a1dec3f8f356307fcfb +d5a9b3e16e2756a30bc62fa92552f73d9d3e02a344f047e3b24ae1392ae90c69 59c513fca0ea668f5c815cfff903279a4e859731 +d5abb2bf61fa4675ce068d8842ac6bcbe7c097d035ed5e79ab83694b92e3b8ae d5ef6a1381ec4cbb9b78979d2ea7c6459a48efa4 +d5c255a2cc319613a97ec8b66dd44e5a8c4d8328a3559840627511c05625b4bb 9514445e534ffb33b50c8752a7c9267e3db3a4bb +d5d0a313ddd0d6d451ce2178da7d7ba19e1f968f3603b80193699ad5a8b51744 068817d917a1c86a5fc33e7925fbee9e2128d648 +d5dee571df1d0b72a7e820d9a08d770561776d044894b626c3ea556cb804b64b ed473e2431c5c013f214e0ee975e3535b6196679 +d6569dea7a2dbf053eb60492f35432622090918137696fd26f01fc69b4dcd67d b32af570d6088f5ec58b08d0f7ad3a74265667f4 +d6a3a68c9c9ac80171333351683d26ca70792679a830155047ca4f85207be32a d4b9769056bc3f7d22860c87fffbe9d4a9065c03 +d6d2e87e6de8690efd26b8c5b58de28dcb3c9bd2b7659eccf34468d71a7a4478 bf55f407d6d9418e51f42ea7a3a6aadf17388349 +d70b0c834e8a1efde1158c15681472b3c7d12da4d1167ed62581e0ca64d184e7 a9e9df3b695e91894be66c30366f0e2bcc73ff96 +d714f59c54cb4bc5a57b9c68b44bf21e2ce63a45f1030baf115ab3c6e7af9709 ef810961d54761c4954df5566da929cba3459561 +d73158b62753ea4eed99124b3dcdc4c873a4ac449204a932b46f46a4da4c4778 8e5a43b2781f75268ca9cbb71993b377cd1d6106 +d79e913b4137117b7f8fc2a8d184373f657d6f71bbeaca0fe83b7757ce486108 def425bf8568b9c1e20879bf5be6f9c52b7361c4 +d7a0fa6d2cc7b83596b51ba9029ee05c553c79eaf3f22298a407c7cbfde61d07 f8588696bcb81e3cf38fc47f2536cf8e25331c7a +d81b2839dc735c3ea774b024636a3f0cb13fe75373e9d1e81365fb1013090e81 89ec4c021467168e5507cf91b712b6873ebe8ade +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca 521d87c1ec3aef9824daf6d96cc0ae3710766d91 +d8bbcaceb334b4a84eae3db74b9201390a13f9cdc2705f5fd68d1c124baf745b 126a72cbe290b3a6a8caf8732e886d3d21c6bed1 +d91051fa024310949c3ea677750d8dded9dd9091ff410826644521c852b15ef6 259ad1a27fc30dc0167d8dd506cb800bd128abc5 +d91df71dc184de6b93ac0d3fced0cdccbdb3f8bedfa433f57aeec533ec657861 65ee31bd49393a45dac5fd1593aba0d332c829f6 +d963a010dcf03c6b21fca8bb99725da1d2443a9dc0a610c5ecbd25f46858a7a2 2bf7e29956df690eb8462a49aa1f8ad9a85047bc +d970d1a6296d149bfb8283b8b4a9a6f7e9ee320c5d46a5ef216e10400df2d281 90d4d2f0fc362beabbbf76b4ffda0828229c198d +d9750ce4daa558910affe057a0a21ff130abafffa5cd3b9bd8857ccff7875543 b370dc5521c2dea03a3d2d1d1209b2691de80323 +d990f65cc071cb0668259dd2f7c1acff8710fe2196fc56e4f43496208ec0edc2 eb7100b307f2c35e7a2d1b05125cb58702da2897 +d9c20b21c4037980a27b4cf716771f1877ccebce89f08b9d07f5b35f4bfff8e4 42281e007e15713713b2ff4324d60360332e194e +da38f65b32fb03ce332e0c4238edae0a733e4cd793d849522bb4e0bdd0af608c 8ef9060a954118a698fc10e20acdc430566a100f +db5ffb15114676bd1246296817d68013ead717c9efd093ffcbbccc805e2b50dd ccb8c44ae6da1b71f65c26324aa39ca35206271b +dbc10ea8c211fef2c138839705ebcf10b6d1261f9af7fb1da206fb8b19050222 bbbf64b0d5c1b962db9d58cadeff78c11bd5c515 +dbd89b614245ebb6f859f64e47f5caccdc93ca05609e83ca5ca2ba478f2d6f31 436cda88b3b747c66549eb0fc0c89d1102f967c1 +dbf3df54acf12a89a09b6f1e7fa9aa29685f419e9a595ec6389181ecd9880bf0 c470e0e0a392d57a681df5d337fd64fbbd9928f2 +dc1d3d6e12bd685f89221ca5051ed749c4ccd59083e2c26d815e6326b8bf8cd7 98822557cf753bf7219fb362c32c9330d35e5f60 +dc8a2c27640a60ce6b6c5424325abfd5d6ca1ee7fcdbf49b7772c107fc0a6cc5 0cf02ff92d5c08516ff2253f59daad1c4c582d8f +dd2e1251481bdf69c7e256ee65ce366ecd4ea43c6aaa61b30bc2d4be17b3fe57 c9280f9f1b0482a337c3250f951431030f9fc91b +dd60b4f51b88aef523ee1cbd6e71b8166b9427c3656cd2d1524cacd9e768e4fb c15648cbd059b92c177586ab1701a167222c7681 +dd6281df774f9e6af8b68a79fbd7c3bb5eab20c85c3385980b8c98141d080c72 36fd65cf283151b18e93dcb5e625fefec79762d9 +dd81a2885ff56d3d275ea52e79809d2c2665fc64949bf3add600d0b19d169f59 2733c6ad2584625f9849e9824927829190fadad1 +dd9b1d5ca653752cef167e034324198971ab6f2f38f3db9db571cb2985759f00 8ed341c55ed4d6f4cdc8bf4f0ca18a08c93f6962 +ddc8a477387d01547a809399b37acb2456faf0b527b5795b3caa5c2d1cd3ecfe 9b3577eda0e6bb13d18a304763b91665575adfd3 +ddcf2e7ae93da5f152a605d82c821b530f88d8f09e5600a09e44e7c89463b3cb 2061cfee59ecd5074bfcc0eac7dc5b3637d290f5 +de11650c5186daa434fa253c05372fc92c34c69af7afdc4137aa62adffe216d5 f9395075e3c7bef6cee2ca5140610896f4855c72 +de82cc04db42cf7ec85c7d6847517ab322ffd81674669fff30b2092c4d10d319 71628d165d4273c15f1ad2320ec382c8f29f566a +deae56ba25b1e1fd5c971fc027ba413e4efebc393c1edab6aa887881d111ce46 21648b45356a49c76d58acf3590bd98ad12b3d58 +deb5d5c69e8ec5f11412724decfcb6913ae501fcecd381350521e3dd30a84cb3 098ac57a13165290bad223e4949fc6f13960b604 +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f a65fedf39aefe402d3bb6e24df4d4f5fe4547750 +def8ae3f46a6251e846b25383d6989ff7931be0906da0e6049d25669df260c7e 53495ca95b5d1fb2db527d35e6a8825bea12b51f +df21e6bbf78ab81e603c9a0eb8a3f2c2edc2659101553405ca57f48d13d49773 5189d8ea8bb07be6dbcc0aaae2294f2b1840d335 +df70ff5ce6431e87f4ecb612cf69aee57b2d8c514e51da1728af6e140ad2ef9d 4870103f0d85d833fafcac9f3eea8b17f9151125 +df7592900e9c0c8191e659cdb9b7a02f0eafc08333ca122bb65f90c466993bbf bbb0d9beb03f3f2d2d81c2199525e7b459f1216a +df773ded7bc7739ffa988358979e1ecf8cba729f6eb8234fe48bd3804d909194 5673434fff718d93ac738a03403442f16abeecba +df7c2829b803b4d008d50676565314253dc23a2f8b80a9d2abec2f8fc027e1f1 6a133ac4d1120d3bbf563d61338bbcdfad4b6ebe +df7ca8caf338f34197d9bc1e346c66690321f27dedcef793f2eb8f99976cfd57 9eb7976448bf684dfb41993ef6c76098978ff933 +e01ed58736f8d22949babb858e5b7c9e9e8c6da45f125c92ff74e4ebc30f678f 6c48d15ce6a8b8cc415eacb9192c5a7b93c3dc94 +e0243b96d2d6668ddccbf4e1744c365b8bb828f0edccc3adeed9cee2fcc0718b 11bb049bdddf1d203dfe8fd6031c4dba328a7525 +e08ee0ca30e32a912f051a443280fd3bbcf593f5e23b5c5a60cd40dfb8b31c38 e3805dff27023ffc98b1e8bb5f8e71e613f134f8 +e08ff41efc23feee5e8dadf3d3901ddbd0e80d4f39c1a893a9b1a4ca6e457c2b 24f3b8d8e8c8f3a1b495bac67d0c493d425ab6e3 +e0920162225ac182b02b72a4999007ce63491fcc0d5fb5b130c8ab6ace46d5e9 36b7cdb6a1a2e685c7141406808366d4c4b9f98e +e0c95bbc34c21872d8a284055d1861b542037744cfcec048c261b5dcaf0d8c4b 15f71b9429442ed616b66b986814e94f983d4050 +e0d289871eae81a3c89d3760d65ec61601a007c010a129ee02f3762961389ac5 e96aa1e25e4ad7dab5d397227ba8f14d302bb393 +e0e636769168575a7c6a7f262ab2e3f24d15aef148224a75949b19bec3204555 09b79f8c2ea7aac83efa086f2ee2377b11c4986e +e13a3a7900774366f6927fbd5006c86b97e0c500873120a4ee73fea158b0a0a7 1ae36609fa336f5d3373eedc18f00c4f05194931 +e153a6b70868bf54a33528407abb749a5ec4a278e36ad587585a807439e75792 001d938dbe69b6251f4a03cf374235c72fd0a0d2 +e15e12b19203d0869a45ad94af16bbad57b91dcfd8d70a23291da3eb39d1db70 87a63e99a903a009e04760bc4fdc195ea25922ee +e1853ed6756da2e3c8c3902b9d373d06158e0e42daf8cd1b364059bcf705825c b42f3f731f6709055f7baf5bce3f39881d4c62ac +e1e91e53ba1b4c377a3a86f493517ed6af162dfcd79191cf0c6ed6cd1846eb64 9c3d59f42c90513a69cb72d3680656ecd6fcc309 +e1f458e5f0d9f51709fecc937aa77830d32d5a06c35fb5a71f37beeaeb5e14e5 9e300586fb4dbcd7a7e7592e8bd36bae946bcf61 +e2040ad7e0b914aab16f77a98f629a8df48c3d5c6346c591a5bf0b6bb19cc6b1 d4627ae2e5d2510b641c806f023335206bb4b575 +e207a266e228414023223530eb77c64b10f2f5124f3354deb45aff04c1db98b9 c059510ad1b45ab58390e042d7dee1ac46703854 +e207de850c812ada0f0196143822e6f60237a7de1f189bad75ad55337706ba73 eb1228f46b3c2adf90a4a4f4093dc12434c71bcf +e2199e776f22c6c9a6f60a74711cf168914dddabef1082bb18027baa9d224c0d c6dbfe02ff6359247b49b0bfbd55dbe659a90def +e2b8d0a4730f8678f5c0bf72165f12a58aea0b5bba85405da8e17aa3e4c672ab d7ae061cab626313265730ce7c33203ea371b497 +e305332f5c4735afd3f441fb9fe7c270df8e8cd77ee73e6f9c00c5cb2cd74c5f 66ae897b9fa0efb9ca0097531be2be366c82d125 +e32cf5f9c0e63f632a2e85c2f57b4d74e352d382fd9e449c5660d5f42696b5b9 88db4b005a4f3883f127d8ff0fa39ea7344d5b35 +e3c7bbc5d5fc396e20897c2124898b3601c494e6051e1a5162938d664e872477 5e95e5342bb02f75240eb1b5978246e2f10c2810 +e43f7ff09259618dd58412fa34610db1c46f6b1f11d7e61c74d8ee91f15afee1 c62b80f26a9b4253aab953c3d860d18ee042bd5c +e486f397c337cb2ab4ed93f7e4bdfe0e96eb2f19b4666b4189d60cc961db4d56 40aa5f7bd409d7467369818208e9eeacae39523f +e488ea88853da32feb570d822cd2458bb7b525f7c946d5956967ea6c2ebde4d5 6a10662131e014c3753a6490644428760fbf1c9a +e4891afff0042d2e3ec44f05b0c973d9bac7bff295b053b614f62377aebb4014 ab9c9b9ee553fd11f9f6d5534e09337c769904d8 +e4cb9e225a817b0f5695fc52c0ce05860a23b345e8338987c7038fd68b46747f 8dfd652805e877abaca7383ad28d8eaa5b9a7e04 +e50daa85ddf947a33ee311516011a786e12a1e5cd1b9b60fe34fcff79af97c6e 0703e6ccf92d6f62c552c7be1af34bfc45fafe34 +e51625cf3375b401cb07f27c258fbe0deed231836136c72670c9beb02f022b52 a45b803b8bc607c1d8fe2ad0f559359574231548 +e51d1f186aaa3e81f6545e45e30138f520f9cddac17f121e3a6dfff5f4286185 d9bb4c3ba46cf7de51761352c7b04a2d49633bcd +e5714ecc9e216d2d23e0c9265aeb7f94917f5445a06e988f40677020a557c1b4 ff7c7576aad8b6d87100eb1a62c0bfcdd6e24e01 +e5a8af67e6a6ef9eab9989c16c19bfeb1503a4d9b3c2100e6a98d07155b0c16f 789527fb457255cc90b2b79dab55b67023c7b8d2 +e5dd60bc585584073807044262f8c611f3c23cbba01562c81ceeb7a046226b28 2e3e1ba4b6f21a028ff2d8f17febfe22fe93afe3 +e5ea38108d603a6ed8dbb0b8455abe6d971f2d60920207e67ba646d267ece305 6f4e2c42d9138bfbf3e0f908f1308828cc6f2178 +e60d23fb634bb7ba008578d69619ecb715555c539e5e1a09995c9fc1a2fc8f89 4324de04e80f5cee8a6d8d72ae7eff4a7d7e632e +e625f75b91fa95253eeb059ff3a4329509939b2af57d406ca6eadbd385441136 6d8e93b8384392ca44be9693c850dfa04b9469af +e64b4ef0c042862ed0071ccc2b2dc8766392d69a1c69ddf9f6e04f61b79bf424 f8ed08a88d6f982e040feeeb2240fec0b5e4b151 +e64ee640eb592c7f2d9592b700c416b96e395d114c13752555ac220d850bc739 2b1ad31b77c1c1e9de3af7863e3916f2fcbdd1ee +e6ffc310d72a72943da3796f9716d5bf6ec72c477eba5d55cd44b542ed50bb8c 2cdc4544233b503a5aff7dd1baa4ba8743fef7ab +e702c3dc4fc84a70aa440a441e905982e17e8c5bf0bdfb58ccf6862ddfe02d2f 963dd0fe0fdb9581df0159efeff615de0771709f +e71ffd37f2119fcce2a02248cfc164238040138822152ce6c8959b35486036ef 06d2a40e85256ae9426dcf3847b0384c547c2252 +e7481fdba48ca2efe4928cbd4a631e313450ec901be85092bfc2428544ea7dfb 1fd98a61779c499739cbc3f34f351eb40d3cb4ee +e7675558e5b9b4a8f0eb006d18979a6019cc8493836ad5b7f06ca75acce29892 02f498e4bb85187f9fbc0b0e2eee06d5c9c27a0d +e77505da06f70c52541f5c07441cf6205da770f7a4fee730757d12962172b93b ed10f7124a75cec05081b751801b6a0a0e42e56c +e77be3b1ba3bd6211b30953bbcb31b52e8c0ac0c68f89ed62bc708caa489cd2d f89099c671ed8df50e040b7a62989b451366d084 +e84639624a2e2f2f89bd215bf640e61374cc0f3385b646d0d59a85bd7baafd62 c770eeb29c9c95d27b9df2d30b6f47d62e78d07b +e85c03d559c7b05c4b6ed5b796dd42a5d018e9f3cfcfdd4645a110e3695f32d6 5071d53225a4dad9e07bd0c9f04a45d0948bad06 +e86d64b9d11cfd3d2a06196fcb3785d0b716500d06b1daba9f582a0368c78b27 0617d6a892682a5d4b4081a759f84ad57b28c577 +e8965fae4238a25fba359135d62087dd0e7fccbae626d5004601b6e9c50461f8 0e7fa1fe6837a46fad03e7fa9a3df0815364982d +e8a865ff7fc36bb0f8cc2460fd7b2977189b5b6144c69e14500d5478cbc9ad6d a79612435aa5b1996ff8ab70e789c8864e55ad00 +e8bbf40ee280bc43b33c04df2250903b75e92f2497e91759cf1cad753c23be6c fc58168adf502d0c0ef614c3111a7038fc8c09c8 +e8dcc2ca3e4e882fb1a824c72543408d014ceaaa04f0657432baab8ee69e1195 8d762aafd2108c0f4fee8133dd2213e3658c66af +e8ef4c26d3c9ea277e490ff6e7d270093e14dbd1c01a3f9d78dc972bac88d87c 46fccbd742b48fecb83be48e16885b86bb299027 +e8fd9ef5c4543a16e74c80cd9bbee3e2b387072a14c7bc653e8f96864b7a4bfe d1adf1be64991ef9c94d836d8075f232b73b640f +e91c29c398d4ba343251bf45e859ee4820c2e5cabef1148565809bfeaf000f5f 2e997a35970424b1d6a6de26f5182898c6bcb1f2 +e92d166df3d560dde2087eb6bb14e2951618a37fced2fba2cce748ea2e159382 a651bba3601c34d3ea21c2cd5b898fad29854433 +e9570c71d360e851fd1945be15a2c4875ebeeba9d9dca7848b72c0e35a562bb0 6457fa0a84176ab4efb565b64170dff4175d68b9 +e986254345a65c0b48ecb229c1f47d9c7b8c03b1dd8cf6cf5bb6a877efac7086 97ba57f428e6d74fdbbe4144b8c9bb46b9ba5315 +e9b7c2531cbe327ebf55552276f330835034014be5e5d603b9f1e1ee5dc28465 9285c652cadce66ec115e1b079648e64a9bf0c67 +e9b83772d89c5948ee301059939d6c37f803e5f6055894a2d169715421d3f0ab 5fc06ac83625f97d0b03000c4c224aa86c3a350f +e9ba6f1e38d419a6e3e66a8859ab291f70cc042192866fe0f0c76229f7acf18d 498bc0906810bd43c6fbc73385fecb7f2d04be3a +ea2ec997ce482c0d1d2b83f7e5bb6c3ec634c2018b8dd4e4a67cb3a108bf1f57 3a2aabdce127a367aa27a4c27025199230e26c15 +ea462d69e697a2d9c70e2445739290c6a4a2d649561c0544f5bb027f9a90248b 58b0cbea74c160c61ec70768568e150c4d31f633 +ea926306b1bab6d3f25f45609907eb6dff91a1460b25e63bf4a0494c70e7a269 9fcf811e00fa469688943a9152c16d4ee90fb9a9 +eacf702e5d2a14313d65279dfe65a9d1be0188107a3cbe5573b268cebe483876 1eea99f3a439dfa65fc9d86f7fb4bc2338fd7dc0 +eb128916f9450004d9468de8c8458ded8db58ba01fbf36201aa16f7255269e30 bc4153d7a1038ee96648f97f75aff45c22501412 +eb38ab81898b34d0060be1e38fffc4e04545dc24ab8aa517550d801e1d98865b 798d19706dbf082766df35d66087d40b1a685a7d +eb61f971c9c8dceec3dfe54fbedbaa9a07e2ebbb0cd44fc38617431fa213ea44 aeef9c0679084b1a3048b81831d4ef3d9d7eb10f +ebb24827556f1cfccf502c909626674796e7e1e1cfd08ca430f3490e9f1622f2 e6fe30dc427d63dde4107715ec219c92a017c864 +ebd4e93650254bfaeae56dbe5ba868427274f867d5d859e406f5981f3ce454f9 4df1521318774135d66161a37fd1a06423d0dc7d +ebead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 1f67fc4386b2d171e0d21be1c447e12660561f9b +ec05ea37ad15fbda3b72d3de3cddfd82b411da97a4dd5dea9bd4c5be71f2fdbf 89528ef257ac5bd32f4980146df41872732ba2ac +ec0afa8e0f8d3f924ae29e9ce6e314f06a3327a596763e7c0afea13c6deff8d3 2066aa3e804f6344b131387e17e64dd20df24cf8 +ec0e609764571fd852ef82c0f2272fd4940fc593dfa28a1a2aa4118f764babd0 f5121b1e6ac7f7e40c08e5c072c05a936d6237c6 +ec12fa9a4f7c288ea3ca253b0cde3250f01f2420de8da0e882e15f7c1e875d3d 2c09181f38234634e478130191323c7f74958c33 +ec1866b39026366e69ab8e167c15312c27f5eda4c0afdf9367ac3d76f56bf8e7 4e7e9f60b7e2049b7f5697daf133161a18ef688f +ec21b1d718a46155b66932c5ea66255e651ff00131904f5c15b13e278ed394ab ee3f1ebf8ca0d0bb7040a888fcefc14873cc1484 +ec9d0c0503395aba37c14bad6f94e30773413e51f4c4192f637be5079922e9b8 37334566347064df74299d0479ba44ee7cd844e4 +ecbf01d97e2c2d6c04e428632edbfe9b67dbbc2f22967c35610d634f8534ece2 838bceb4b87e6a65042f955c90fdc809b34ba3ba +ecc250a19bce5bb071ba73708879b69c8d93cc655ba47964873087260da82532 872ad88d663eb6eac5365bd64f0d2ed2820b2017 +ed1002021629a4a96d2d53168633fd4bec45fc52a4dc3514d09becfb1f4846d1 52121c9b19c8a7625126766102b2a8145c1c0632 +ed10f9520d5f0d6bbd9c467ed83a239df0cba94ae9031602e02f6ad6256c459e 4fc3874b118752e40de556b1c3e7b4a9f1737d00 +ed41f28b6dec2c88eb9b4825a1ec79f770ddd524ff8e8c8dc117697cd8f3f039 1f3ae5e22cbbd99f678fddf3eb1a86726cbca831 +ed994d1acd346cb201da40004ad4f59cd42270537a086298c89f81873ed078d5 0fa9bc03e0832bd0e4f9b9a4735a3301bb37a8d7 +edf6e0dbfaf8a7ad89b05b5768981eeedd7a2bda4b1d0fae07aa2a9d49bb39df 32679a9544d83e5403202c4d5efb61ad02492847 +ee16964dd77360202417cb8e958673a3be107fcb1551a7b71f6985d2102c472e 7c297e8eb9ca1fedca286fb5877353c7356c380d +ee4981c3f6d4d973a1f7d99998848fe4b778ed2762a31cae46f9090bf47aa0e1 a7c182c59414cece10c819989bce3f1247f4eacc +eed74bc11a8f6e68a63c093bcb7b793c3a77b18239d9340a75dd690b4e790dc1 ddc1e625381d4fcb00107f5640030d0dbedcfd0e +eee9bb8a199012d24a2f94bb633930f5bbdd4b59d7aeddd430d7d5b0c0abde4a 960ca1d7799e02b72ca828373c3fff04e2cf0334 +ef08c989d6195b9dbc09f3053b94f642d84925d5d5f3a2dfd28be482d77f1d97 3aa9ebb63e642246946ca397c8498df46fe6db0a +ef461668dec669ddde121af3bfcc11f173be86c4fee529001cc95e22ead79a2b 8e9e1e4f95e44ecfc1230a91036257ccbefe605b +ef5dd9207c9041337f20818723f4baa003a8e0e55646ca726a62b4e7f831583c e3c672819ce10dd2207fd8df6a52eade74f00996 +ef9f17d60e921db4ae02169736de6f4da6b6ea76cf3419ca30494fbe2a40f0ac 77bad856f6306f1c1243ce0f4e363477205d3cbb +efc4b8fd4b0b2586fce256b107ee2a052d11d26f99d85ce0478c3d49d1b2186b 8edc2805f1f11b63e44bf81f4557f8b473612b69 +f00a3d864ac7cc74bfc0d238ba10b171fe7b6f5f2dbe7aa08ea07f99865bafd2 5bcc94ea49a378e97626436c5b28be17b54eeac6 +f02b8fcaa64271d82d9021dfea900a09fd74997a61c21642da82fee6e6b20f21 f3687dc858ea475e3691834bf4ec00a2fe8c3b27 +f039acbef00c0dffe624ad124760b27a085358a81f9ddfc071a2eb2e44035097 5841342a0a9453dca640dc53d2ea18ed70409c86 +f043d8f788777ec076d2e6072c36ecebc8772847e7effbd7fb04256181ea1e65 f09aecf46ef68bfb4da47e593082805ebc644d5a +f08cad6328b43e133362254e1468ead13b1a5f39a22d45fd956a90a0a860b401 32db4c9153f750f183f5f6a11e4a1e5f093a739a +f09899f54bb2a1feee2a205c24b5c2e9ffad5ead4fe15b2f21285ae0c973ec60 18f4b6b56c084ab586170cc47e5f8d55ffe1add5 +f0a7a226654089b999b5c92b34d304a9a7c7c874a6484b2437909a6dd225e382 a4f863af4d0055126435eb01278940aaf727d2b3 +f0b7aba704d8816667f0465022228bbd93ec18502f1ba75d0e4105c49ddf1a99 0b30644f7cc496eaceba0130713c7be51021bd72 +f1982fbf726534f88311eb2eac67ebb828c10bbedbe596ddb956413b5e9e1f17 4033d6b8cb15107abc2288b64f405d595f4d68f1 +f1b2af9976ce14a31b39e96b27b97a72606393c5f87c500b933795959fbc5122 9bdb75947178f72df30314d66bc9bcc90df643d7 +f1d8da2c2039b56e385ff2f76f1f2585b5d708ef1b8b5527f253a335ada68d83 88ccfe32b8a8455a7d6e709666494c33c7387050 +f28ac33bebcfce2579b1e8e91bd6749c7b06a7e5825bd6fc2375e3e724f20612 5235041760e8186f96bd757bfa378ce5adc90b4b +f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 944c0f6e4dfa41595e6eb3ceecdb14f50fe18162 +f2b78ab9d3df69f23d3e9a9e03b63a466a06c760c4eead34f90e10187f86acc2 487addc854add2a93bfb25f29cd7a5c2ce3bc40f +f2c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 bd758010071961f28336333bc41e9c64c9a64866 +f2ccc71ac9c89dd36f44b911594484abb969c62f640f9cbf60c853896b6d1d13 93a527ab2bf2555e28fbdfdf31960326c4055d2f +f2d5807c5279cfdfcf302fe93d1ac90025a03a57132ea1d852f80f0ba0a1158e 898dabc73fa99e31f117c366498046cb33c8a24b +f2f432405c8298ed098d704a9590d7f41451b16c834520580fc1270fae0f8b17 bce499af70d434e89c9a110374f1b7c6dd3621df +f31459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 75057dd4114e74cca1d750d0aee1647c903cb60a +f32ab793f10b04cea82cb3bda32a0b9595b5f69ca89608f88d3572914de6f720 feb1bd8ab25180e447be9862c852a45143e98375 +f34224f82528a95407c2202f0340d08ce68435c02c440932d4a098ace60907cb 022d8b4e47f1ee40270ad3beafaeb5c025ea1b76 +f355aa3c4819d7e2e235e2638c11eefff5ea1872c2304889bee6e843da7a382b 3d40a87326d25342300fb50d78744671440c5408 +f362826c827aa3bcbeb3ff8b71bba08d7440b89ab53fe95d61b8922d01f46e28 e0743ad4031231e71700abdc6fdbe94f189d20e5 +f3c7b2b4491f7edb2150c74d063ef6f49c81ed818d8b447215f3b6c3f6091cbd ea59a210dbab63d18bbb616fc27087d68dc59777 +f4076ec94766226a8ee1d52c84ffe070d8d58cfa111e845bfc7e3e99e314f19f 43288a0733c1dc0a506a1e45087bb7f9bd87d047 +f430e24c70cbfe819b5f201e3ebc34a3dad712ceb08ee4f13fd8bd07a6fa6d44 ea28d017cc7a2b9a329dec6bd91236f5424d72b6 +f47bbbbe82207974769ce35769b74de8abc56d4770efca4a2cb755d55c150390 6a840ebc2b332a23243a5590965eefaeeb460bcb +f47e3b2db30186f550ec8c5c0182409514e10cdd3e66a936e0ce57349df8eddf bf05bcbabc31dc7627bccd33535c5bcc6be2498e +f47ffce6447e860dd48eefbbd7aacc7aca083eefbf2df94f9b96113c58c08206 ed8ab62f1be3062011dbb3c6033952e4657abd94 +f54e47e3fb25c0fdedf1a58eae2aafa499f95c821b702623778455cbe8cba53b 2e85427e16f2823de8324bb47d07f6f78a38746c +f5656eab7d016da5fbe176ba06fd46f809e8f3163fc143887055f4dadfd829a2 86726c5a8c1200f732412fd3ec7601f3d2100801 +f5a821e9f70620ad45e86113ee0ee42211caedeb0db3ff3088500dda553c046f 00a27258320f37a893d4c8e52a991997706c730c +f5be968ddbfc5aba6d676304dd513eaf8b5fb877235c1d5b8c76e8a93f24bd0c 5fcb851f4bbff2968e56b9792ce8310a2eb50002 +f5bf0317f8e2f3280613bd0f1574b5d9f2f0760b0335091ed3fabcab327af221 1fd9c75f95b22df3f52a0891dd36d3c18e9fc0d2 +f5c6feab3b2b51d205f6bc4b3d8fa2a8307ea5f61031b711204778104bfdcb4a 61bfa90a8f4300c31966e3309cd2461507b02264 +f5ef3ebcfc8f054e80fd190746057638615b9479d3917b594e00838ae2b69890 7b7d17f9b6bcb21de339efa2e1ffdef5f15cc5d3 +f5f86c720ab7d820ae97ab3ee2efb1009109a3a54dafb4e986b4f810b7016d21 8c7833b361ef6a4c68d72865bbf312fc3d806ce1 +f63c392c2e03143c9c3b37fdeea26691076a424f336b45bbafe3dcb4537ad29f 129156d84004e59c894c7e273ba9b5824bb9ea0f +f63c4d6eb84809e54f87f531118170c28758305df7888104365e74742cdac390 2ee716e9a389bfbb76261371c1e65348ed1b9a38 +f64b9eec0c8df9ad7a5a2a50b9bbdb9f8da4b55c9f3176cde323aff07de313c8 e2b5e2857b75278155944594c2beee36079b6b1d +f64f370eb4726c47b6c90efe54938119ebc024e49fe07e7eec0207b42827b98b e7ed799defef0499d47c8d8330955ab387ad8852 +f65ec16ed7554295cfdd98a0a5b67c1995c0b7b2a6778c8b36ea2e5b94cc5902 75f541f109d783d298a774cb9f6e1e7891965949 +f6633a3ba290c6e9f4b37ee0d3532e47cdf16cb2a43a7049ff3a3210044e3121 29c52c3a0cda152f11dd39d6217b46f6f246bb40 +f66691f32eb9b23a029b43251bfa994d16481fe97903057e121b76e4e78f6ff4 c01c3fae7251098d7af1b459bcd0786e81d4616d +f66c29d989b01cf3feb6fb2bb7329f8acab284376c3b860f3d7e0fff904c4298 532a2f46e4a8ffc15bb5a13d9a02364197115d63 +f69bc64f14b90aa437c84a4b4d0e4ace3bb8c911a16ea8d77a6ed781c1956a02 9396ec28d49129250ff79463cf588e1a8512984f +f69f3d4f7b8713dbb3e3adf1f64d6b8f88eadb77bf4f358fc28c32c756b5df9f d42c7e287c39463759ee11e4fe7bc9d722e487f6 +f705853cd543d8f69b6e57c3bd580ae4cd8b6ebcac63460fb322e0133cd0dfa9 406ee23fcb2900af9eaaff243f20ec9e07494920 +f718026e4badd0b9b38989a5538a627858e3319cd8b155925f00daff5768c138 7f73f247cd1be8def4d07063ddb72bbb2e6ade45 +f76f10b126720bb7d7577603fb3b54f0cf0ca722fdbc29c924379f4ccff97c14 09197a342b635784bfbaddcf6b8afc01d142f8f1 +f7c7c0e0d32eefee600c90a65bfca1564c643d30451276d3a4085930586db81d 8a086f872a3bb2cf8e437f0e374ea18e5cbaa899 +f7cbb8c92f729f08203f027870bcf2a1a71c94199408c3bc6bb7f06859212989 187613a431e241f9aff9884bfee28c3ca82ae1eb +f7e772589bf8ab335ea3a7bb2c2d8158755e0b2bc08b34d80eaf50d070fe6607 083f644dce33ceb8318ab7f1fcae008d6bae2b7d +f7ee8274a6a3963b96ba1b041f25ff1136cbb2ff07ffe04566f321f02f4099dc 2b8988ea7a90b45116bc4d4101fbdc678c48b410 +f7f06b26124f95366b331eea19be3182ff9dc0ea208ea1de2235e22249683a1e fafedcb78f9bf54e54f0a819ad1461c2ae3b4463 +f82729f2cc042ac51302f20404d9e218148448a3ed6d6c7936b063aa4532eb80 4d5b2a922151ea86d986e012971896622f5d3f77 +f88e32bdeb55ef0690249212cf64c42a4255101a95b74e3dbf78e6ba34f67def ac7c4c450b9a90d66957511688dcddcd011281fd +f8b2eda314c8c39ac692033eade0bc766ca39c8e8c0a40fc0a25c67fcda825da 3a33c7b37f55d5bd30ff944625499e64919b9a9d +f8b45f792840019909fd35f9dcb98082b3bc39373268d467e1b00f1da5ac71e5 cff54d138945ef4de384e9d2759291d0c13ea90a +f8e91f003a1b5b5c5c842f5a27be8f5054c71bbd97ec516d0d8293f4eff40372 160148d67a3f12f0f393e23bc4b7e4e58c0eb921 +f92a00b48199229aedc6c30dc4157eb40b364efc1d843f91b67fe7113681ecb3 5130f2343aa863e7f17ddc0c65f71a993b061a07 +f979948512aa2fcdcad17b3fb76c3cbb196f28f88af5aecb1c29b2f2bbfa51a1 ca9840588d1718b996d4e0987b2caee0931e92f2 +f99100a033a521b0bb725db49ff10e6f27bf21ee6a18c3bfdfce294a3c70eb93 d4043ee9d97031e94f205110996d2381dd26c540 +f9bc81246e5d5f703bc5cfcf7dc637f1ac952dfbb4ece2f84d68d84e1bef99ff 713417dfe4608035e6615918b57a6edd78a3955f +f9e46cd8f3f9eba5b9530820893f31ec9b135df075cde7e1331ec1834616a405 29a61a7f86f3703914b82d1d06b1c6e2775c684d +fa2a467607e74eeb7d2865994f8a105837ad47c7f34d930a219544a187899dae 4428dfb78da0d5cb229763c8ff3278f6f4ee5bfc +fa2ded3190944dfaf1a56eee66b9e298edc098aa834ed57952f04771f7ad5f45 de141d4bb983dad861835e181e7ecd5692a58aba +fa50bed23c21de9e38ae6492dda179c028b9b618cfffec62311cd8e52bd90a12 d0f0c327029d770d1b10efc7a6c93080ed7d6844 +fa6a2b7e588e57115d2772c0d5250d886757404fc510a5956be8de4926e94c01 4f1355c91100d12f9e7202f91b245df0c110867c +fa9b280330449aaf7fbd9709144d458cd54593a29045c6562a840a8580a80554 8cc293419bf3b5eaf51c8a90f3a1a86c2b415121 +faa7ca59426e17f6b34fa407d06cd634faaabeb4abe26df12296e05a17c98eef bfe05675d4e8f6b59d50932add8790f1a06b10ee +fafc05a1d0b7614ba32f428eb52f3439ffbfed9a817e5ae069364cfc3fa3e4d4 fe1ca6bd22b5d8353ce6c2f3aba80805c438a7a5 +fb21dc7e0744c92621f4d94df822be5c275d509431d647c5e1cdd0cee85a57ad 2e7e8953cd4d7bd21729b29e1f7eae3ccf941b20 +fb56a4825bdf67a9ccfaf2d3962c16c49294fb565743f8ef3b3adf6ff721e729 47c31f584e09d79f3674987582a60c7bb6b673c0 +fb74b8e06683d2154d9ca50317e5e3581e1d0dea24229d4aad83ff0296e384bb 44bc212b00ca8cbdcc2751bd48534ee274318445 +fb93630decf348bd577c39423a6905f7f119e371eb098d0199e888fbee4154fe 0be51ee21b376c8848207ef5608aa7b3798d5020 +fbb6481c1ce45e504fe1233d0aaf228384b9739908d69d753da9fa7baffdb64a bc5aba43f785c144c9b5c6406ffbce6a7fec5304 +fbc60a067b3286e1547e78c5d195099580125b2b80e8e44716a313a4ebb66e6f 7a3b12fc4fb66960d4660e3e24af873bc07ac932 +fbc712543e696976405b7a070164abf6ac7f379b66f74dc2538563d4380a2004 7a6cf8153799563464d6f1761e55352c327b4122 +fc2157d0df676f018ad7a001a8150b8c5cae4313e50a69021f90cc82d8c0366d f9e43c1b9b200572edf0dbf333184151db14b711 +fc36ce993654a9c2f2ba5944b90d9fbb8b52bf3e45da4efcff1b137812573e63 8ba79944d51268d80b65372d508cf4d0ba239a4d +fc7d032290d1d7af6b021e29f190d7a534aa3a31ecd9fd72e4a246ba7dc13e96 edc21d065b345f6af9ab4c3f07acc3f137436b27 +fc899c4e3fd5e61b944f9a9d4bc143888a80f4a11836024d441d0fef00cd355d 75636f4771c5ccf864814b83431ab7cebb091506 +fcc409c956764fbd4904916ec1a1dfb00ad9492ad11aa85fc272b94ff2412517 427c5e85811a8c7062c2c4621342e4e9c445817d +fcfa61e2c38f220b1cf11a62ae7f6120b699c6f4fcdc0b0e02d31cfc2f1550f4 661900993cf98d9854e4d9c8584ae215e1eba148 +fd21b90bdf88489115886ad6a66f842e4b3b99f2c47c74f107a3012206a0975d dd583895e15b6ddbcca3ee7e8a1f7d8b39c25d1e +fd6ab50ef7201a166b711edd386b9649ea052562bbab8a09ae5714f5f9c5a24d c215be4120385fc5f358e8a0609c94f6998184e7 +fd77de19e02087045739e074b6368724fd41d66a3e196b96c4092efc76b9a325 f83b69a6538188e9dad0b6dc09e5476bf36c9a1e +fdf50c9b7119e7018b4a2f5c3235802104674e7d467f86608c7fee73c22321df b2bc567f25e3e07d0d6d55fab16f33423d863107 +fdf78aeb5b52940bbb069a7e2ae5495b1e77fcf4f9bb699bbe2b8372526bd3b3 b31b32f52231610f4e8c2c98e1ba5834b323555d +fe191677f9b0be2d6232dffe0d8cf68edec0106e1c57efb1f084205ab56389b4 88bb8fe275f64c587e9d2f960cffa059d2b76fb7 +fe20b68ee605e6b7aeed310d188b6b597f7c184dc10166f645a683d77bdcfd7a 03770969aa16f40d4192c733408f152fc17b1f19 +fe9a766dd36f1a877fcec8eedede85556ff031d42678699c5350ee9117498a28 339a0ed36a822ace408b5084f8e3bc3e63b868aa +fea0d6a630e0c517db1c57ab26a4229f48ac0cb61563777509633198bb60eadf a5274d8192aca15b24b1c7ddcba42726f5418ea4 +feae789c354caab8c9f38b38e18c04c41d7381d402eab1ca87befdeb5fa62539 65654b679591001c402b3925a31ea80f9e083969 +fec50a36447cf7f413ee48757b0f3d80322f3939d984556bda46600139cb5a89 0234c186bacb5144ca13f69f0dc9bfcc8ec7a075 +ff04d2f2105e9fc8f103e4b5840b46b3914a317e9c53cf523be81ca59cb5f023 6d34f01ce0ab2a3a198bd43ec250a5062d8e1217 +ff14a5e654a9963042a8183b2c7c356bb52440bc05f62ec193ba77a94c1f5290 bed3229b555ecd18bc7824c3ead7d2372b5f4f5a +ff1854a73752a8779bf1d78e840d85b7e406fcc16a4cb7d1bb6a35bc60da49bb a52aa75b56d579790985af4ade1e73437d50b414 +ff3f1e98e17179dc0503307f2a01732096ea309288c2ceddcf71dbcce290691a fe9d965dc040c687edc1acefeb5a7919b14c6340 +ff503ebb130051b71bc883c83861389f4f4a66ebcfd5c05d5b2a7b805e45e773 143b052f17fbb3ac1310ecdb2bce4a10b9d2821e +ff77a7e762c77408890442669da2a3a6ae2d0f130e8b953ce85edd0b81cb6f5e f7cce7c2d30260da7e0cc04e14ec618b832ce327 +ff77d10d1335090c32371bfb5179f915266de4425afaf4387dfca0bf2f6f98a2 86ff216d8fe665daecde956b38de7ec33b074477 +ffbbfce866283c7571b728f367b998d05b3767cb26600953db1b237b442fc0bd 16a67770b7d8d72317c4b775213c23a8bd74f5e0 +fff5cbc10ffea865d69aba64082ae17479c522e8e0305e678469749282bf0a18 afadc73a392f8cc8e2cc77dd62a7433dd3bafa8c diff --git a/tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b/tests/resources/testrepo_256.git/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 new file mode 100644 index 0000000000000000000000000000000000000000..8d8d1d8e82826ef293e6194fd62fe58b610a64a9 GIT binary patch literal 267 zcmV+m0rdWO0iBRBP6ROwMXBc$>9zvdiQ_mDLNt_gTp&*D-IdrKG|YL6N#fP{&9f?`+(G`CnaXJ-;gRl4TtnA|jaTt3=n z*F6BD0K$ZVZiHIL+~Lp@3%g0orO)8SWCrd*Y5>rsv~%Ki%}9 zua~EQv7}g#D2Mx550*)%o!$O>zr5OZwD21f4wS62%-3_1h&jb+T9u{~z>%^>08ZHb R5YE?q4eR@e%QrEBc<=pegz5kQ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 b/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 new file mode 100644 index 000000000..c7fbd7e9e --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 @@ -0,0 +1 @@ +x[NÅ0 ùî*üt•8§B°”Øq ¢iPš»º~GgŽ42zo œ±/kªÂ^rfK‚¡FO%BI"NªÉdwVe¡b8º”vb‘·ß<õ\°LçB6Ýk< ÅUtœÅ–¢%¦ÄÈÅYÿ#SµÔCè·ü\ßcÂù<Ž5~ô„7í:›<ªÎž¯¯žÛñÑßÁ:›n3&‚WƒÆl7½£–þSß>Kkt…Ú½ kÀõäҦʳéµý÷_‘ \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b/tests/resources/testrepo_256.git/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b new file mode 100644 index 0000000000000000000000000000000000000000..cdfafaca76c5125ec895dd2db23dacb7deb81805 GIT binary patch literal 103 zcmV-t0GR)H0V^p=O;xb4WH2-^Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_Lb5a<#Nl)SGxmmebk0Gq-=z%#(tY)Q;ZmYb?_SQI4`tl&h J1OSNDCE&90Gx`7k literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 b/tests/resources/testrepo_256.git/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 new file mode 100644 index 0000000000000000000000000000000000000000..b135eccdafadfd5a8e548e5fd10adbb00a8af34f GIT binary patch literal 21 dcmb003G-2nPTF literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f b/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f new file mode 100644 index 000000000..58b2d0932 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f @@ -0,0 +1 @@ +x ̱ƒ0 ÐÔžÂ#ÈB k„¾¹ä‘ j²}(^ûrÝ«Ùãô¶¬²„i3ÏÃg¾’õ _ÜœÝ8H§Ö¡N] “Š”ü}P·ó8žYò®o;¾o\Wùw×  \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 b/tests/resources/testrepo_256.git/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 new file mode 100644 index 0000000000000000000000000000000000000000..97157644b1b473df7cc6a9233900fe07123c0b02 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATcgeZG}mfxK8yPV&{~SjE literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e b/tests/resources/testrepo_256.git/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e new file mode 100644 index 0000000000000000000000000000000000000000..554d191b3aca70ffde00fcf101d4e9a9875cc1a9 GIT binary patch literal 92 zcmV-i0HgnS0V^p=O;s>AV=y!@Ff%bxFfcbvHcT=xOSUjINisGxv@lIgv@|z2F-}S~ yOSAwoOw27AHcoA~_Bf$(bLz>G#hz97>XR;=ZS4NsQ6BTFNcIU^-(CO?b{=3|pCc*& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 b/tests/resources/testrepo_256.git/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 new file mode 100644 index 0000000000000000000000000000000000000000..d5c518ecc8c721f8632f0bb8ea332f8a97a5497e GIT binary patch literal 236 zcmV_=Q@ zvc^JrmF}Qg=!O7r?zLNUX-aCt6-~5{l4I4ZRZTgp^D02}=TX1{#hFVf*erreuEopX zmDsxD7%`+ZBO8p_oyqEor3M02%1i&Am;Fd@zR#InF5UNQdi?U=@O<9-`^SUt+fzcS mxgjgmbPp9^xwW@vX8dQnyvA{kWJkaHC7tY`)A9qv31^C*IC|Ou literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 b/tests/resources/testrepo_256.git/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 new file mode 100644 index 0000000000000000000000000000000000000000..31aa9e5f53d3533a3a8776bb36eae93699a46384 GIT binary patch literal 162 zcmV;T0A2rh0Tqlv4uUWc06q5=dp9B5rPwwx#t(Qi-n(?cDg^@7gx`zF9Og1pLJ!*E zVd9sx1xz%j=&kl*sF99h#|?KJ(7T9yA|cJho+8>>J5M5=#mML^N^Ol%Wt#=sDd$vF z+27*PY2?56vcMy?G8VXnr6f3)Fi!8!wa+09)gE0ylhciLbz|X(gs9a0nO4{d@RenQ QHRX8_*msrs0f5OkO$&%m&j0`b literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a b/tests/resources/testrepo_256.git/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a new file mode 100644 index 0000000000000000000000000000000000000000..66dc15db4869b30415e10f5559c83bd21e1cc737 GIT binary patch literal 143 zcmV;A0C4|!0V^p=O;s>7GGj0_FfcPQQ83XfsVHGMvvq;(iZJ#=1{Vca|LU9;dT|3^ zs-}RH!xjCk)2ws<&o?mu0)=FTDBZA`{}!8tZ_!@aqqM!Vd)0!si&z)QtiQAU!B21Y x-LoO;Qc@W#_e&k>IsC&}d-?fyr?UV5oyGsmvBGyp?4#HG;oCzkG66E(I?6KoNm2j+ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b/tests/resources/testrepo_256.git/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a new file mode 100644 index 0000000000000000000000000000000000000000..bee6a42d79b08c80d27f1ff7f4f95189f55eb8fa GIT binary patch literal 202 zcmV;*05$)30d>z&N(3~>FKgs_E z!mZY07>DpMx`cxEQtzPe1=EZwDosY5K@}CF97|2nW9;RP@0Itze E*nhHQlK=n! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 b/tests/resources/testrepo_256.git/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 new file mode 100644 index 0000000000000000000000000000000000000000..3dfd5463ba9d6f8014964d36504bcb9b30ea3e74 GIT binary patch literal 238 zcmV5HexU|FfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCA{-mnQD!Pj~T~x!O}-`s1Jbv8On1ZSwhS_#jYl%lU(gp~~}fQW&;L oPvPphS-Dt`A*|`>fjLU7W~GmAtGvqg);Lr8@*u|q05@b{udX9}%>V!Z literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 b/tests/resources/testrepo_256.git/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 new file mode 100644 index 0000000000000000000000000000000000000000..cedb2a22e6914c3bbbed90bbedf8fd2095bf5a7d GIT binary patch literal 19 acmb-^#&K@VmFECanOevRMB$i#Rc`n6$Pz)g@z MiOzronCJc{NQdPt6aWAK literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 b/tests/resources/testrepo_256.git/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 new file mode 100644 index 0000000000000000000000000000000000000000..1b299dc257b712a486bb7ec5bd07720d88001374 GIT binary patch literal 38 ucmbxW_qÍÇ×!û÷›Žãr`t¼Z¶Ö¬t=ší?¬˜Û~Vø1ÅfT \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 b/tests/resources/testrepo_256.git/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 new file mode 100644 index 0000000000000000000000000000000000000000..711223894375fe1186ac5bfffdc48fb1fa1e65cc GIT binary patch literal 15 WcmbBQQQ6W+Sv9;eTEK4oHX{LN+y0Ic;3tpET3 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd b/tests/resources/testrepo_256.git/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd new file mode 100644 index 0000000000000000000000000000000000000000..8dc1932822c30e3289f0b6a74ce1d27f99fbca04 GIT binary patch literal 57 zcmV-90LK4#0V^p=O;s>4WH2!R0tHJm21zbq&mf(H@@-9zz0NE-=O?!!p!aY2A)ohG P61T;?x-bs_fTI)&EzuSA literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b b/tests/resources/testrepo_256.git/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b new file mode 100644 index 0000000000000000000000000000000000000000..dd993131694c0525737a02638048b52c66a7e051 GIT binary patch literal 64 zcmV-G0Kflu0Rc4t%Kvn7Wn~~VH2^U%Fg7$aATus>cys_Z>cT|@)WkqoWX$sO4SBB@ WgLD>cuFmhj5#sPz(+yzy7#1e#x*6;M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 b/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 new file mode 100644 index 000000000..39e27c06a --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 @@ -0,0 +1 @@ +x1N1E©÷îRÆöØKÑPÒqÏxœ”]£#®Spº¯'ý÷¥/}Û.ÃøäŸÆ¡j\å1‹KRP€8RDImªPšºÌ!´ˆD>“pÈÍú¦ìš[¾Ë¡û0µºàµ•¬›D ‚¸Œ‚hëSf !ƒ‹šÙÆ@©éµ-üyÀZ S>©¢å\çn¬ÖSŒ ]É€Cl¸äÂT[#GM|Û-å>Ö~˜úSŽj¾Ö¾Ýún^uÒGz?_ÆzçéÛ›±.y—,b0ÏS ˤó¡ÿí/ŸzœÕðQvYÍévçÇÉ·“¹ì£›~­Ë/(jrS \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f b/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f new file mode 100644 index 000000000..17fae64f4 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f @@ -0,0 +1,3 @@ +xuKj1D³žSô¤–Üê† !'H. OgÀ3 +²Œ¯9É6»¢¨÷ rݶµ2>õ¦ +d=‹Š²³³-bŒ5ì‹“dòÅ•Ä„¦Pî(DÁeŽÉ{Òé+6Ý;Ì>±‹4KÆĆ­¦rLfˆ Á,ö¿Ýo}© >ríÞ–˜ë/×üNç-®—ç\·W°<[Çâá`‚1ÓhÇ£® ÞË=¶ŸKÝ®Z‡ñ‘Nçµ/·ôÇ{"‚ï?¥÷¼À¯ê®Ó7bÆW \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e b/tests/resources/testrepo_256.git/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e new file mode 100644 index 0000000000000000000000000000000000000000..0bece845b96b3be7ca7f12ebd967e1764ce64fa8 GIT binary patch literal 157 zcmV;O0Al}m0V^p=O;s>7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~Aa_@sq4IM2{ir(cMHr#0REbn7~n6Kme4WSKw2k&aU L-~1H-4}m~Ae2hy! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 b/tests/resources/testrepo_256.git/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 new file mode 100644 index 0000000000000000000000000000000000000000..112998d425717bb922ce74e8f6f0f831d8dc4510 GIT binary patch literal 24 gcmbBwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPl<4>~n;v^*(#mvh)~qtUaxkNsi3j_)^wHuxR9 NtMPvGR{&K(Dn}t?GcEuC literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed b/tests/resources/testrepo_256.git/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed new file mode 100644 index 0000000000000000000000000000000000000000..4c973ea83afb1efa8040be2204a65922df718df6 GIT binary patch literal 181 zcmV;m080OO0iBOAP6ROwMX7U&^hn5d;v|+3+6z!|g4l61Be4t`viIMGBhY-k;=SVA zalP&>8mP{?jXCQ!Je}|U;BMlVp*fLKANE=x! literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 b/tests/resources/testrepo_256.git/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 new file mode 100644 index 0000000000000000000000000000000000000000..67b84c462af40737559130399874eeb4b77a3873 GIT binary patch literal 108 zcmV-y0F(cC0V^p=O;xZoW-v4`Ff%bx2y%6F@pWZbw`lHR)+>Bwx}Rd~@4XFW`Wv>f zX+7ii5?;+J71zneN1>|oQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtu2R4DnfG&Y$4 literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f b/tests/resources/testrepo_256.git/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f new file mode 100644 index 0000000000000000000000000000000000000000..993a62b1637039118d63bec43013bdb924745aa8 GIT binary patch literal 141 zcmV;80CN9$0iBLp3c@fD0R7G>asg$xn`|nG2p+)`sd4(!0hkIsFwuiRDb vbB?*M_O|CAJf;?x_a*msw>ShM1{&F(Apn@e9w#dQv_@suWu43yI6^)tb_75M literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c b/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c new file mode 100644 index 000000000..70bf64e16 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c @@ -0,0 +1,2 @@ +xÏAj1 …á®çÚ‚-i,B(]µ(tiÙ2’™ ƒ=~]zƒnÿÅ÷xe_×¥Æù©f]òb¨µ…$Öa­9)yI Ù'ñ‚2i«èæYÉÇTU[f™îù°­ƒWVaÔ©5sùu,QãÜ +¢¤€¤:„P’OœCp*£ä)?ú×~Àùó'x]6x˹\­^àÜöýžóz¿Ù©ìëWVbXmdf7@IP_Uo6IJc=qbL zq|eXzbl+;$b4H&}E1;_LQp@#9DoPk~<1bCz&7bb#H*>Y8zVydG_hV0S-rD5z+3-Q2 O;Fj|T7Xtt@NhwLRz&0BI literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 b/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 new file mode 100644 index 000000000..09d0abfa7 --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 @@ -0,0 +1 @@ +xQJ1 „}î)z¥M›¦<‚'HÓÔýÁÝÊZïï¢7ðm˜ùf`tîû}y ú°N3?RÌÈ6§BŠY¹wÈJeH‰R(…LÐM¬•Ì‰±€û”ÓŽåµA#8z½€‚Ú ÄPµ¥ÔµæÈÀ5¨d(:XH¾2ÁÉ÷Úæéßt®å_7ÑyøÛ—þŠ—÷]îO:÷gr©röBp—{=ZöŸ®k§ºù¿ ?s?T¬U… \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe b/tests/resources/testrepo_256.git/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe new file mode 100644 index 0000000000000000000000000000000000000000..70431af8128d71fe97407bd3333bfd6953435891 GIT binary patch literal 137 zcmV;40CxX)0iBLb3c@fDMqTF=vlk?jO#VQ`3%K$GnaPv}EQOlh-|7+Ee7wbb@X5L? zeE{Zs8k;Iaov<*Wb3uZSWkNwqjY7*U2c2qR8xjZ4NK9O~_|jUUrgHcWP2I=5Zt&ks34~NnJYDK-@s& literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 b/tests/resources/testrepo_256.git/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 new file mode 100644 index 0000000000000000000000000000000000000000..41bcd18afbb47ff313b90874fa27decf3a34b5cb GIT binary patch literal 188 zcmV;t07L(H0iBQ0O$0FvMETw-(g4VD5<8I)x*s~A0Vj6Ylh_Mda=P{jE%5i|Nu$xU zaU9p_knw4rW)4t$3Ay#^sZ^*`1ynsrQ)Oh65-4`om|IHHO>qUyxnzhysczqL+HE?v zNFj*%3YJ5Hpw%Qs&%J1BO*&%D%q>Yw3rW4=nuG#o*r{)FpZhr7yFTPp_py)TXWZPY qE&E58&+FXp^`(vD&3WX2M8%VP1_s!cU9YD7x4(@q-F^W(?^Up9reI0hYPWM?<@LE8o(K`PkZiyW2X8cRHOfV>{BnkIcb` X82t2c`iq#_jy^W?S6Y4mjhI&pAZBds literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b b/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b new file mode 100644 index 000000000..74b8385ed --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b @@ -0,0 +1 @@ +x+)JMU0´°d040031Qrutñue0~"ºÃtYÁî›2¾_,Ækxö꺤ÏÏøtßjÖsFŸO+L €@!1‰A¹+@æ£s¾¾JÇ>‘õIÞêÏ]³äœ¾àWÖÞµS¹ Æ&%æ%għeæ¤ê•T”0L;ØÏ4ýq/ã—M·ÎÞ[¢:ëU¶fâk¥½:<ö šÌ ®Pmy©å`å¹ñ—&îæOwñ›¹ÚS_úãŸû±§8omòùlø PpËùƒ‹¨TO \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 b/tests/resources/testrepo_256.git/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 new file mode 100644 index 0000000000000000000000000000000000000000..2419974cbc27d6c1afe3e38ab5a7b41ee67782a9 GIT binary patch literal 244 zcmVj1=F9WRbosttAR+ya|(cx z7H!qI3QFrHv9V~+$!AGYqzQRbni&u${T|DHgb&-t2yctpzJ=$z{f5`;s<+Q4+t-&6 uv7{OkAcaRL0Mkj&XNLc$JH7jH_0SI8YzdcD@2BSyZrj*Th|>?YL2LiRRDL}G literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 b/tests/resources/testrepo_256.git/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 new file mode 100644 index 0000000000000000000000000000000000000000..b390250e308a62f1afc44c5f8e99e8196c1949ae GIT binary patch literal 63 zcmV-F0Korv0V^p=O;s>4V=y!@Ff%bx2y%6F@pWY|ej>WVbXmdf7@IP_Uo6IJc=qbL Vq|eXzbl+;$b4H&}D*(}y6gC9)8?68U literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 b/tests/resources/testrepo_256.git/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 new file mode 100644 index 0000000000000000000000000000000000000000..18a7f61c29ea8c5c9a48e3b30bead7f058d06293 GIT binary patch literal 26 icmb4W(dj1ELH%b#5{%koD_wmqQt!93`H&goVE$TEmshD literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 b/tests/resources/testrepo_256.git/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 new file mode 100644 index 0000000000000000000000000000000000000000..3e36331ea660f96ddc6389c51c0b5b04bae31f94 GIT binary patch literal 190 zcmV;v073tF0iBOqN(3j0%EkJD$BPXewzWa z!-|SjiYX>T;Sx)U;<=r*<^V|U%o(URa?V)6q-3Ma8tbC>xs4-y*qAfCZ))QfUVrR& sTt0Wbe!bY(-$G1+k|I$F&maKHNzX^q|Klzi`nVr+3xAd60TLfo5g`3pC;$Ke literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 b/tests/resources/testrepo_256.git/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 new file mode 100644 index 0000000000000000000000000000000000000000..9bb5b623bdbc11a70db482867b5b26d0d7b3215c GIT binary patch literal 23 fcmb4WH2!R0tE{b2HziV+t#c)dZ%e?s$#*+oF|c&=UKVPO^@7W Px?zvs8Rx$M(km5$Qz#fi literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 b/tests/resources/testrepo_256.git/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 new file mode 100644 index 0000000000000000000000000000000000000000..be8b99bba80435c6152a727a07b56daeefda6569 GIT binary patch literal 198 zcmV;%06G770V^p=O;s?ouw*baFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb*9efIuNJi9xw5K<1+qbH2Vx1ILX%k@ZR58|u$pv*et<;8)h( zwNtsE#wHad<|Svur)B1(>XlTKFibnx&oupUFXNX@x6a;MqB`qUwr1jM4yC<1JoX8i z%nYtjZF#BXVCB{kVQ~-AKN@?U_3vC|nJe&JCi7v&)gyh2Y@bdyd1JK^0G=>TfAl9| Ae*gdg literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 new file mode 100644 index 000000000..9d2ceb1ff --- /dev/null +++ b/tests/resources/testrepo_256.git/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 @@ -0,0 +1,2 @@ +xŒÁ‚0D=÷+önbvK[JbŒ?àÍxßÖ¥¢Öƒ/™I^æð” P»1=%+X’5IœO6“´uà =V•“*pDòì]h±v˜„G/„÷HÜ,o £¿€r1Ë@eÖŠLpë² +ž´ƒ£ò0¾¾çÒs÷>ä±?ÙH¾ŽÎ!ìÑ"s}t3,åͳIÿmø3‘ \ No newline at end of file diff --git a/tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 b/tests/resources/testrepo_256.git/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 new file mode 100644 index 0000000000000000000000000000000000000000..cfcdac3069711e3c0e4779477c932e2e4dea8d59 GIT binary patch literal 182 zcmV;n07?IN0iBOAP6ROwMX7U&^hn5#9Vd|x+6z!|f;e_GBe4t`viIMGBhY-k;=SUJ z<9gj!Oaf2qbdTZ_n=+=9MLKjX*PZtCZX kuRjmE{LagMyhS9gML1QC&yWDZ_&c=xA8DX)2hjgc&6D$5qyPW_ literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 b/tests/resources/testrepo_256.git/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 new file mode 100644 index 0000000000000000000000000000000000000000..77d9ec27d546841923f4d7688b1675af7e8e4d09 GIT binary patch literal 187 zcmV;s07U014!Q&1J`S7%pUi!~ zFHa>stW(ujOsS>X`(UW5qgJUb4eF2>VWG)N3h{_=-}`0|#}?&_IpZ=o@DON9;t+k5QzLE6aaV8>(SExxQ>sxwoCnsxF4}jRtl?nS=|5t literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f b/tests/resources/testrepo_256.git/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f new file mode 100644 index 0000000000000000000000000000000000000000..a67d6e647ccc1f3faad53aa928441dcf66808c42 GIT binary patch literal 21 dcmbtwae_U^_9p60<==wtq&H!0qWh{lmAp z@3$2T<)?Lw5xq!G%^L|QdS~f%8-3dbn}R9Q0Bmk&<*ou<3B4LSp*E>N;aiSzUok6c z#afH@2JWS)BU%^M!Qd!vrBtQ@s+$5CXGS4PT2E&MgFM!C9`VEGTJilVHt+HE$Nu2* jxy$YA#peDNGvvYuR46{Dno>CJ`Dl&*Y(w}3o8?f{IrmoS literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 b/tests/resources/testrepo_256.git/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 new file mode 100644 index 0000000000000000000000000000000000000000..225c45734e0bc525ec231bcba0d6ffd2e335a5d0 GIT binary patch literal 21 dcmb7v0yMXFfcPQQ3!H%bn$g%Shr~IVb&{rX1bqZ?C-q|W%?Vo zv1vWy_7YyrDizns#zlZq1ak~8AdGILV(N-9bi_I_f^(s(Gwyl_2>Xx)=lH!DQc z=RajI;oIyMKK=CNeacX6d8y@K<=zLK8ai5@6urwiY`D?rS>DI~Fki>_8$uiW4&K#x LzxgWw+t)xa*56Lu literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 b/tests/resources/testrepo_256.git/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 new file mode 100644 index 0000000000000000000000000000000000000000..04bf5eb0621c5e6a453ac232bf04198f7a6a04ce GIT binary patch literal 192 zcmV;x06+hD0iBP*ZNo4O0Q>e7TA&4KQIrG}ML*e~3s52%=V3c=6=eOmEA)3b;2zia zb-j%+=lV7dv(UVEf=tpAX49FJv4MzGj;VSC>QQ^mR+GobGgni}WKxJlB~5oZY#RX( z3m~|)f^LMZsxz@-EX7v0yMXFfcPQQ3!H%bn$g%Fn%Js!*p4}?iiagzF#cHYk2nR zx}?v~_;lZD)^kRmPb;9RlZq1ak~8AdGILV(N-9birXB2On*O+#@yn)LXYVaho%JeP zGx0Tt(q0`N`vgs923M%Iywq~A^4$1K6L<5cyZFsq?Wr&Q@z4F(Q=GRp`Fu8f5Gc6i L{K3Tl{;EGa8DLRL literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx b/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx new file mode 100644 index 0000000000000000000000000000000000000000..897e8a478fcd5da84a4faf07f1d47e873809c40c GIT binary patch literal 1336 zcmexg;-AdGz`z8=LlH0n9gPix{4*FaGtgb6ViusDfyAsp`$sY9VZa6qw;_XdTSbe? zt)5tGZM8A@8Pr~PYgJ!anh zD`si9^@YFJi=Vu@&DZ9b?P0GIaKf^6-s!gAVT%eEF>R}PI?XA-h^~1Nyk|gsYf%8$~m*)2`Jr>GVb$z9txX6d+H=mR&5mLJN9RQC) BmmmND literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack b/tests/resources/testrepo_256.git/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack new file mode 100644 index 0000000000000000000000000000000000000000..9c8557886c820187eb37b4d68a70c42aeaccc895 GIT binary patch literal 569 zcmV-90>=GNK|@Ob00062000J-5qO-Pj$uj!F$_lk&nbEVB~6od3bF`$1W%Bpsk`WG zWwzq=9rXtO`*`pk-`w2;wv{6nEG3CkQdEV?l)4M`l%YmOG|C22jVfvL#-^!3PkD}hK!yfe5D3>oHH~qFf%bxNX*MG$w)2I zE2$`9h_qJIzJA~cZ{jp9v!5?#m@w_{_Kt{3a$Qm_CS@pT!EOlAQkp9Tt4u9XNX*MG$w)0y zNXyJgZmc$_QGNGwrE%gjl&=K=s2`2)UmErk_wcRJ)dE3lPA{-pC@ky0#1 zz^TNPz3p7H(DMS}c$`Z$o?r|B1B3xwxPKoZK$x+d;F7Po?{0QOWjq7t`5&q$w`b$) Hf+g_whLjGt literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx b/tests/resources/testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx new file mode 100644 index 0000000000000000000000000000000000000000..9e2ec99c546e6de5f8279f1abfc0f254565d625b GIT binary patch literal 66216 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%0D&XxF~7)M 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�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 z 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

    9=o=@S6W*>`s-(zXqsv0npSQxIwyF$! zAQFx+P`qqSK4xO;iprLWC9{+oqPA2~U##HA11}E7JhVIS^kzZllfhBj7z{o4)Kr3k z6A3`*1Ri|{F;X#s{=iTG_a(GnHS+veci@1*^DY8!2FT%#JSL6L2O5nmp!VOMr_skD zgilhq@g|@sE{Uf81 zPv{*IF7bzC

    Vovz`T)T`;Ya#$Z0SHa|PfeI+1{6}s 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

    =mM5&%b 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 VkO2&l#Yv$+QtYmHNi3Nj{}+t}`m6u| literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx b/tests/resources/testrepo_256.git/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx new file mode 100644 index 0000000000000000000000000000000000000000..1d197e87085e32a838da41a976b0dbf13938628b GIT binary patch literal 1336 zcmexg;-AdGz`z8=qk!}fU<7KRB?iUIKx1a08>od@fM!t>vjWW|?pt)*BaNFAyuP`%y7il{<)*l^up!FyVBLILX1~6UNj$>y7hv+?ty1Foih&9c8$9gZVTN(b|vv=+n z%vY#cef;}9o3l0T7e94ekq+)qb=qWeh$CyJ*trPpZY`#4Uej*2!>e|k<5Vsvk1x8F z`%9#=a4pwHFQtQVS#mr{Q3uw%)UbRqOEe-N)H^;`N0UujbJgVEHTHi0cWu3Y$MxLK zpUXA3KYsl0)3(#!e%|Q&dsA7I#cSe0dj`fGuHSS0ez(6`_s#Zi{DH~88P9h5PoBX8 za<(VeAqN45_n*7=abMb;A|~*W`QDLge}8v&U#5+p>zV&KtO$0Tx=zVq?E{J0XHvmM z5#?NM6N)^_4mjvcoe{j&?$m`Dv!>6vyUucog_rS`m&K6}??tAyYOlTZaEXcj`nR8E ztk~bb$0vP*UUZ3}2tRvCN80w_@TvAe#gqFFUfn%$QOBLO{Y5s*lYAdr>(2I0yPnUfJA41>o9i!$GHl)_^lURw zGqx${veU9^^TXL&loJDdfzC2AGQx0KM)i`y;->57*SAgA zJ|i7bzI2!Azy7+KBWX(y{>!QC)t>f|L13~N&sIhpE@NT{O=oZWuDyS8)X%0v%h*jt abs9GLy=*)$pu0Ui<#6-Q9hIgRE&~9e7#2MM literal 0 HcmV?d00001 diff --git a/tests/resources/testrepo_256.git/packed-refs b/tests/resources/testrepo_256.git/packed-refs new file mode 100644 index 000000000..995685f08 --- /dev/null +++ b/tests/resources/testrepo_256.git/packed-refs @@ -0,0 +1,3 @@ +# pack-refs with: peeled sorted +66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb refs/heads/packed +cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 refs/heads/packed-test diff --git a/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob b/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob new file mode 100644 index 000000000..2723f8909 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/blobs/annotated_tag_to_blob @@ -0,0 +1 @@ +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca diff --git a/tests/resources/testrepo_256.git/refs/heads/br2 b/tests/resources/testrepo_256.git/refs/heads/br2 new file mode 100644 index 000000000..2abd96e09 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/br2 @@ -0,0 +1 @@ +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 diff --git a/tests/resources/testrepo_256.git/refs/heads/cannot-fetch b/tests/resources/testrepo_256.git/refs/heads/cannot-fetch new file mode 100644 index 000000000..2abd96e09 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/cannot-fetch @@ -0,0 +1 @@ +a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 diff --git a/tests/resources/testrepo_256.git/refs/heads/chomped b/tests/resources/testrepo_256.git/refs/heads/chomped new file mode 100644 index 000000000..de0d95305 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/chomped @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/haacked b/tests/resources/testrepo_256.git/refs/heads/haacked new file mode 100644 index 000000000..5feda4d41 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/haacked @@ -0,0 +1 @@ +7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c diff --git a/tests/resources/testrepo_256.git/refs/heads/master b/tests/resources/testrepo_256.git/refs/heads/master new file mode 100644 index 000000000..106231c4c --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/master @@ -0,0 +1 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256.git/refs/heads/not-good b/tests/resources/testrepo_256.git/refs/heads/not-good new file mode 100644 index 000000000..106231c4c --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/not-good @@ -0,0 +1 @@ +decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f diff --git a/tests/resources/testrepo_256.git/refs/heads/packed-test b/tests/resources/testrepo_256.git/refs/heads/packed-test new file mode 100644 index 000000000..7c2c5e438 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/packed-test @@ -0,0 +1 @@ +43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b diff --git a/tests/resources/testrepo_256.git/refs/heads/subtrees b/tests/resources/testrepo_256.git/refs/heads/subtrees new file mode 100644 index 000000000..3b352e1ad --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/subtrees @@ -0,0 +1 @@ +0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 diff --git a/tests/resources/testrepo_256.git/refs/heads/test b/tests/resources/testrepo_256.git/refs/heads/test new file mode 100644 index 000000000..de0d95305 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/test @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/track-local b/tests/resources/testrepo_256.git/refs/heads/track-local new file mode 100644 index 000000000..8f6ecbe2b --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/track-local @@ -0,0 +1 @@ +b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 diff --git a/tests/resources/testrepo_256.git/refs/heads/trailing b/tests/resources/testrepo_256.git/refs/heads/trailing new file mode 100644 index 000000000..de0d95305 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/trailing @@ -0,0 +1 @@ +4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 diff --git a/tests/resources/testrepo_256.git/refs/heads/with-empty-log b/tests/resources/testrepo_256.git/refs/heads/with-empty-log new file mode 100644 index 000000000..bd392a7d2 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/heads/with-empty-log @@ -0,0 +1 @@ +7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f diff --git a/tests/resources/testrepo_256.git/refs/notes/fanout b/tests/resources/testrepo_256.git/refs/notes/fanout new file mode 100644 index 000000000..307abb49c --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/notes/fanout @@ -0,0 +1 @@ +cf84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 diff --git a/tests/resources/testrepo_256.git/refs/remotes/test/master b/tests/resources/testrepo_256.git/refs/remotes/test/master new file mode 100644 index 000000000..ee4aa140b --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/remotes/test/master @@ -0,0 +1 @@ +1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 diff --git a/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob b/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob new file mode 100644 index 000000000..2723f8909 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/annotated_tag_to_blob @@ -0,0 +1 @@ +d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca diff --git a/tests/resources/testrepo_256.git/refs/tags/e90810b b/tests/resources/testrepo_256.git/refs/tags/e90810b new file mode 100644 index 000000000..eb8846a05 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/e90810b @@ -0,0 +1 @@ +21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 diff --git a/tests/resources/testrepo_256.git/refs/tags/hard_tag b/tests/resources/testrepo_256.git/refs/tags/hard_tag new file mode 100644 index 000000000..05dfe0615 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/hard_tag @@ -0,0 +1 @@ +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b diff --git a/tests/resources/testrepo_256.git/refs/tags/point_to_blob b/tests/resources/testrepo_256.git/refs/tags/point_to_blob new file mode 100644 index 000000000..5efdc777d --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/point_to_blob @@ -0,0 +1 @@ +33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 diff --git a/tests/resources/testrepo_256.git/refs/tags/taggerless b/tests/resources/testrepo_256.git/refs/tags/taggerless new file mode 100644 index 000000000..45547b7fa --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/taggerless @@ -0,0 +1 @@ +14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f diff --git a/tests/resources/testrepo_256.git/refs/tags/test b/tests/resources/testrepo_256.git/refs/tags/test new file mode 100644 index 000000000..a7d2fef64 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/test @@ -0,0 +1 @@ +c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 diff --git a/tests/resources/testrepo_256.git/refs/tags/wrapped_tag b/tests/resources/testrepo_256.git/refs/tags/wrapped_tag new file mode 100644 index 000000000..05dfe0615 --- /dev/null +++ b/tests/resources/testrepo_256.git/refs/tags/wrapped_tag @@ -0,0 +1 @@ +34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b From e89e2e0102300af1faf0ab892e598a700692718a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 24 Jul 2022 13:33:58 -0400 Subject: [PATCH 08/22] odb: rename test file to avoid underscore In clar, an underscore is meaningful; avoid using it incorrectly / unnecessarily. --- tests/libgit2/odb/{packed_one.c => packedone.c} | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) rename tests/libgit2/odb/{packed_one.c => packedone.c} (87%) diff --git a/tests/libgit2/odb/packed_one.c b/tests/libgit2/odb/packedone.c similarity index 87% rename from tests/libgit2/odb/packed_one.c rename to tests/libgit2/odb/packedone.c index 7a1d3d913..9af27e8c7 100644 --- a/tests/libgit2/odb/packed_one.c +++ b/tests/libgit2/odb/packedone.c @@ -6,7 +6,7 @@ static git_odb *_odb; -void test_odb_packed_one__initialize(void) +void test_odb_packedone__initialize(void) { git_odb_backend *backend = NULL; @@ -15,13 +15,13 @@ void test_odb_packed_one__initialize(void) cl_git_pass(git_odb_add_backend(_odb, backend, 1)); } -void test_odb_packed_one__cleanup(void) +void test_odb_packedone__cleanup(void) { git_odb_free(_odb); _odb = NULL; } -void test_odb_packed_one__mass_read(void) +void test_odb_packedone__mass_read(void) { unsigned int i; @@ -37,7 +37,7 @@ void test_odb_packed_one__mass_read(void) } } -void test_odb_packed_one__read_header_0(void) +void test_odb_packedone__read_header_0(void) { unsigned int i; From 479c8c8c14f83491f31fb9b23388ae17070c9549 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 8 Jul 2022 17:17:09 -0400 Subject: [PATCH 09/22] packfile: handle sha256 packfiles Teach the packfile machinery to cope with SHA256. --- include/git2/odb_backend.h | 66 ++++++-- src/libgit2/commit_graph.c | 5 +- src/libgit2/indexer.c | 19 ++- src/libgit2/midx.c | 5 +- src/libgit2/mwindow.c | 7 +- src/libgit2/mwindow.h | 5 +- src/libgit2/odb.c | 15 +- src/libgit2/odb_pack.c | 120 +++++++++----- src/libgit2/pack.c | 156 ++++++++++-------- src/libgit2/pack.h | 44 +++-- tests/libgit2/odb/foreach.c | 11 +- tests/libgit2/odb/pack_data_one256.h | 21 +++ tests/libgit2/odb/packedone.c | 9 +- tests/libgit2/odb/packedone256.c | 78 +++++++++ tests/libgit2/odb/sorting.c | 6 +- ...76d752efc71661592db317474a0cf292915f31.idx | Bin 0 -> 1376 bytes ...6d752efc71661592db317474a0cf292915f31.pack | Bin 0 -> 1406 bytes 17 files changed, 412 insertions(+), 155 deletions(-) create mode 100644 tests/libgit2/odb/pack_data_one256.h create mode 100644 tests/libgit2/odb/packedone256.c create mode 100644 tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx create mode 100644 tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack diff --git a/include/git2/odb_backend.h b/include/git2/odb_backend.h index a31d1b782..4d0559ec0 100644 --- a/include/git2/odb_backend.h +++ b/include/git2/odb_backend.h @@ -24,6 +24,26 @@ GIT_BEGIN_DECL * Constructors for in-box ODB backends. */ +/** Options for configuring a packfile object backend. */ +typedef struct { + unsigned int version; /**< version for the struct */ + + /** + * Type of object IDs to use for this object database, or + * 0 for default (currently SHA1). + */ + git_oid_t oid_type; +} git_odb_backend_pack_options; + +/* The current version of the diff options structure */ +#define GIT_ODB_BACKEND_PACK_OPTIONS_VERSION 1 + +/* Stack initializer for odb pack backend options. Alternatively use + * `git_odb_backend_pack_options_init` programmatic initialization. + */ +#define GIT_ODB_BACKEND_PACK_OPTIONS_INIT \ + { GIT_ODB_BACKEND_PACK_OPTIONS_VERSION } + /** * Create a backend for the packfiles. * @@ -32,7 +52,38 @@ GIT_BEGIN_DECL * * @return 0 or an error code */ -GIT_EXTERN(int) git_odb_backend_pack(git_odb_backend **out, const char *objects_dir); +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_odb_backend_pack( + git_odb_backend **out, + const char *objects_dir, + const git_odb_backend_pack_options *opts); +#else +GIT_EXTERN(int) git_odb_backend_pack( + git_odb_backend **out, + const char *objects_dir); +#endif + +/** + * Create a backend out of a single packfile + * + * This can be useful for inspecting the contents of a single + * packfile. + * + * @param out location to store the odb backend pointer + * @param index_file path to the packfile's .idx file + * + * @return 0 or an error code + */ +#ifdef GIT_EXPERIMENTAL_SHA256 +GIT_EXTERN(int) git_odb_backend_one_pack( + git_odb_backend **out, + const char *index_file, + const git_odb_backend_pack_options *opts); +#else +GIT_EXTERN(int) git_odb_backend_one_pack( + git_odb_backend **out, + const char *index_file); +#endif typedef enum { GIT_ODB_BACKEND_LOOSE_FSYNC = (1 << 0) @@ -100,19 +151,6 @@ GIT_EXTERN(int) git_odb_backend_loose( unsigned int file_mode); #endif -/** - * Create a backend out of a single packfile - * - * This can be useful for inspecting the contents of a single - * packfile. - * - * @param out location to store the odb backend pointer - * @param index_file path to the packfile's .idx file - * - * @return 0 or an error code - */ -GIT_EXTERN(int) git_odb_backend_one_pack(git_odb_backend **out, const char *index_file); - /** Streaming mode */ typedef enum { GIT_STREAM_RDONLY = (1 << 1), diff --git a/src/libgit2/commit_graph.c b/src/libgit2/commit_graph.c index 9554fe855..bf557f7ad 100644 --- a/src/libgit2/commit_graph.c +++ b/src/libgit2/commit_graph.c @@ -538,7 +538,7 @@ int git_commit_graph_entry_find( hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_sha1(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id); + pos = git_pack__lookup_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -726,7 +726,8 @@ int git_commit_graph_writer_add_index_file( if (error < 0) goto cleanup; - error = git_mwindow_get_pack(&p, idx_path); + /* TODO: SHA256 */ + error = git_mwindow_get_pack(&p, idx_path, 0); if (error < 0) goto cleanup; diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index 62bb70393..98408646a 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -179,7 +179,8 @@ int git_indexer_new( if (fd < 0) goto cleanup; - error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path)); + /* TODO: SHA256 */ + error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), 0); git_str_dispose(&tmp_path); if (error < 0) @@ -468,16 +469,16 @@ static int store_object(git_indexer *idx) goto on_error; } - git_oid_cpy(&pentry->sha1, &oid); + git_oid_cpy(&pentry->id, &oid); pentry->offset = entry_start; - if (git_oidmap_exists(idx->pack->idx_cache, &pentry->sha1)) { - git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->sha1)); + if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id)) { + git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->id)); git__free(pentry); goto on_error; } - if ((error = git_oidmap_set(idx->pack->idx_cache, &pentry->sha1, pentry)) < 0) { + if ((error = git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry)) < 0) { git__free(pentry); git_error_set_oom(); goto on_error; @@ -522,8 +523,8 @@ static int save_entry(git_indexer *idx, struct entry *entry, struct git_pack_ent pentry->offset = entry_start; - if (git_oidmap_exists(idx->pack->idx_cache, &pentry->sha1) || - git_oidmap_set(idx->pack->idx_cache, &pentry->sha1, pentry) < 0) { + if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id) || + git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry) < 0) { git_error_set(GIT_ERROR_INDEXER, "cannot insert object into pack"); return -1; } @@ -557,7 +558,7 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, off64_t entry_start) pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); - git_oid_cpy(&pentry->sha1, &oid); + git_oid_cpy(&pentry->id, &oid); git_oid_cpy(&entry->oid, &oid); entry->crc = crc32(0L, Z_NULL, 0); @@ -987,7 +988,7 @@ static int inject_object(git_indexer *idx, git_oid *id) pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); - git_oid_cpy(&pentry->sha1, id); + git_oid_cpy(&pentry->id, id); git_oid_cpy(&entry->oid, id); idx->off = entry_start + hdr_len + len; diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c index 51b2d6cc7..b09055237 100644 --- a/src/libgit2/midx.c +++ b/src/libgit2/midx.c @@ -392,7 +392,7 @@ int git_midx_entry_find( hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]); lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1])); - pos = git_pack__lookup_sha1(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id); + pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -549,7 +549,8 @@ int git_midx_writer_add( if (error < 0) return error; - error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf)); + /* TODO: SHA256 */ + error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf), 0); git_str_dispose(&idx_path_buf); if (error < 0) return error; diff --git a/src/libgit2/mwindow.c b/src/libgit2/mwindow.c index ad649490a..b8295d9d1 100644 --- a/src/libgit2/mwindow.c +++ b/src/libgit2/mwindow.c @@ -61,7 +61,10 @@ int git_mwindow_global_init(void) return git_runtime_shutdown_register(git_mwindow_global_shutdown); } -int git_mwindow_get_pack(struct git_pack_file **out, const char *path) +int git_mwindow_get_pack( + struct git_pack_file **out, + const char *path, + git_oid_t oid_type) { struct git_pack_file *pack; char *packname; @@ -86,7 +89,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path) } /* If we didn't find it, we need to create it */ - if ((error = git_packfile_alloc(&pack, path)) < 0) { + if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) { git_mutex_unlock(&git__mwindow_mutex); return error; } diff --git a/src/libgit2/mwindow.h b/src/libgit2/mwindow.h index e32ab99d4..8e6df2613 100644 --- a/src/libgit2/mwindow.h +++ b/src/libgit2/mwindow.h @@ -48,7 +48,10 @@ void git_mwindow_close(git_mwindow **w_cursor); extern int git_mwindow_global_init(void); struct git_pack_file; /* just declaration to avoid cyclical includes */ -int git_mwindow_get_pack(struct git_pack_file **out, const char *path); +int git_mwindow_get_pack( + struct git_pack_file **out, + const char *path, + git_oid_t oid_type); int git_mwindow_put_pack(struct git_pack_file *pack); #endif diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c index aa2dd3cb2..edf4f001f 100644 --- a/src/libgit2/odb.c +++ b/src/libgit2/odb.c @@ -684,6 +684,7 @@ int git_odb__add_default_backends( ino_t inode; git_odb_backend *loose, *packed; git_odb_backend_loose_options loose_opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT; + git_odb_backend_pack_options pack_opts = GIT_ODB_BACKEND_PACK_OPTIONS_INIT; /* TODO: inodes are not really relevant on Win32, so we need to find * a cross-platform workaround for this */ @@ -722,6 +723,7 @@ int git_odb__add_default_backends( loose_opts.flags |= GIT_ODB_BACKEND_LOOSE_FSYNC; loose_opts.oid_type = db->options.oid_type; + pack_opts.oid_type = db->options.oid_type; /* add the loose object backend */ if (git_odb__backend_loose(&loose, objects_dir, &loose_opts) < 0 || @@ -729,8 +731,17 @@ int git_odb__add_default_backends( return -1; /* add the packed file backend */ - if (git_odb_backend_pack(&packed, objects_dir) < 0 || - add_backend_internal(db, packed, git_odb__packed_priority, as_alternates, inode) < 0) +#ifdef GIT_EXPERIMENTAL_SHA256 + if (git_odb_backend_pack(&packed, objects_dir, &pack_opts) < 0) + return -1; +#else + GIT_UNUSED(pack_opts); + + if (git_odb_backend_pack(&packed, objects_dir) < 0) + return -1; +#endif + + if (add_backend_internal(db, packed, git_odb__packed_priority, as_alternates, inode) < 0) return -1; if (git_mutex_lock(&db->lock) < 0) { diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index 49a655b44..814c0bc75 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -26,6 +26,7 @@ struct pack_backend { git_odb_backend parent; + git_odb_backend_pack_options opts; git_midx_file *midx; git_vector midx_packs; git_vector packs; @@ -95,24 +96,24 @@ struct pack_writepack { * -------------------------------------------------- * * # pack_backend__exists / pack_backend__exists_prefix - * | Check if the given SHA1 oid (or a SHA1 oid prefix) exists in any of the + * | Check if the given oid (or an oid prefix) exists in any of the * | packs that have been loaded for our ODB. * | * |-# pack_entry_find / pack_entry_find_prefix - * | If there is a multi-pack-index present, search the SHA1 oid in that + * | If there is a multi-pack-index present, search the oid in that * | index first. If it is not found there, iterate through all the unindexed * | packs that have been preloaded (starting by the pack where the latest * | object was found) to try to find the OID in one of them. * | * |-# git_midx_entry_find - * | Search for the SHA1 oid in the multi-pack-index. See + * | Search for the oid in the multi-pack-index. See * | * | for specifics on the multi-pack-index format and how do we find * | entries in it. * | * |-# git_pack_entry_find - * | Check the index of an individual unindexed pack to see if the SHA1 - * | OID can be found. If we can find the offset to that SHA1 inside of the + * | Check the index of an individual unindexed pack to see if the + * | OID can be found. If we can find the offset to that inside of the * | index, that means the object is contained inside of the packfile and * | we can stop searching. Before returning, we verify that the * | packfile behind the index we are searching still exists on disk. @@ -141,13 +142,13 @@ struct pack_writepack { * -------------------------------------------------- * * # pack_backend__read / pack_backend__read_prefix - * | Check if the given SHA1 oid (or a SHA1 oid prefix) exists in any of the + * | Check if the given oid (or an oid prefix) exists in any of the * | packs that have been loaded for our ODB. If it does, open the packfile and * | read from it. * | * |-# git_packfile_unpack * Armed with a packfile and the offset within it, we can finally unpack - * the object pointed at by the SHA1 oid. This involves mmapping part of + * the object pointed at by the oid. This involves mmapping part of * the `.pack` file, and uncompressing the object within it (if it is * stored in the undelfitied representation), or finding a base object and * applying some deltas to its uncompressed representation (if it is stored @@ -177,7 +178,7 @@ static int pack_entry_find(struct git_pack_entry *e, * a prefix of an identifier. * Sets GIT_EAMBIGUOUS if short oid is ambiguous. * This method assumes that len is between - * GIT_OID_MINPREFIXLEN and GIT_OID_SHA1_HEXSIZE. + * GIT_OID_MINPREFIXLEN and the hexsize for the hash type. */ static int pack_entry_find_prefix( struct git_pack_entry *e, @@ -251,7 +252,7 @@ static int packfile_load__cb(void *data, git_str *path) if (git_vector_search2(NULL, &backend->packs, packfile_byname_search_cmp, &index_prefix) == 0) return 0; - error = git_mwindow_get_pack(&pack, path->ptr); + error = git_mwindow_get_pack(&pack, path->ptr, backend->opts.oid_type); /* ignore missing .pack file as git does */ if (error == GIT_ENOTFOUND) { @@ -270,33 +271,34 @@ static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backen { struct git_pack_file *last_found = backend->last_found, *p; git_midx_entry midx_entry; + size_t oid_hexsize = git_oid_hexsize(backend->opts.oid_type); size_t i; if (backend->midx && - git_midx_entry_find(&midx_entry, backend->midx, oid, GIT_OID_SHA1_HEXSIZE) == 0 && + git_midx_entry_find(&midx_entry, backend->midx, oid, oid_hexsize) == 0 && midx_entry.pack_index < git_vector_length(&backend->midx_packs)) { e->offset = midx_entry.offset; - git_oid_cpy(&e->sha1, &midx_entry.sha1); + git_oid_cpy(&e->id, &midx_entry.sha1); e->p = git_vector_get(&backend->midx_packs, midx_entry.pack_index); return 0; } if (last_found && - git_pack_entry_find(e, last_found, oid, GIT_OID_SHA1_HEXSIZE) == 0) + git_pack_entry_find(e, last_found, oid, oid_hexsize) == 0) return 0; git_vector_foreach(&backend->packs, i, p) { if (p == last_found) continue; - if (git_pack_entry_find(e, p, oid, GIT_OID_SHA1_HEXSIZE) == 0) { + if (git_pack_entry_find(e, p, oid, oid_hexsize) == 0) { backend->last_found = p; return 0; } } return git_odb__error_notfound( - "failed to find pack entry", oid, GIT_OID_SHA1_HEXSIZE); + "failed to find pack entry", oid, oid_hexsize); } static int pack_entry_find_prefix( @@ -318,9 +320,9 @@ static int pack_entry_find_prefix( return error; if (!error && midx_entry.pack_index < git_vector_length(&backend->midx_packs)) { e->offset = midx_entry.offset; - git_oid_cpy(&e->sha1, &midx_entry.sha1); + git_oid_cpy(&e->id, &midx_entry.sha1); e->p = git_vector_get(&backend->midx_packs, midx_entry.pack_index); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; } } @@ -330,9 +332,9 @@ static int pack_entry_find_prefix( if (error == GIT_EAMBIGUOUS) return error; if (!error) { - if (found && git_oid_cmp(&e->sha1, &found_full_oid)) + if (found && git_oid_cmp(&e->id, &found_full_oid)) return git_odb__error_ambiguous("found multiple pack entries"); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; } } @@ -345,9 +347,9 @@ static int pack_entry_find_prefix( if (error == GIT_EAMBIGUOUS) return error; if (!error) { - if (found && git_oid_cmp(&e->sha1, &found_full_oid)) + if (found && git_oid_cmp(&e->id, &found_full_oid)) return git_odb__error_ambiguous("found multiple pack entries"); - git_oid_cpy(&found_full_oid, &e->sha1); + git_oid_cpy(&found_full_oid, &e->id); found = true; backend->last_found = p; } @@ -425,7 +427,10 @@ static int process_multi_pack_index_pack( } /* Pack was not found. Allocate a new one. */ - error = git_mwindow_get_pack(&pack, git_str_cstr(&pack_path)); + error = git_mwindow_get_pack( + &pack, + git_str_cstr(&pack_path), + backend->opts.oid_type); git_str_dispose(&pack_path); if (error < 0) return error; @@ -596,32 +601,33 @@ static int pack_backend__read_prefix( void **buffer_p, size_t *len_p, git_object_t *type_p, - git_odb_backend *backend, + git_odb_backend *_backend, const git_oid *short_oid, size_t len) { + struct pack_backend *backend = (struct pack_backend *)_backend; int error = 0; if (len < GIT_OID_MINPREFIXLEN) error = git_odb__error_ambiguous("prefix length too short"); - else if (len >= GIT_OID_SHA1_HEXSIZE) { + else if (len >= git_oid_hexsize(backend->opts.oid_type)) { /* We can fall back to regular read method */ - error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid); + error = pack_backend__read(buffer_p, len_p, type_p, _backend, short_oid); if (!error) git_oid_cpy(out_oid, short_oid); } else { struct git_pack_entry e; git_rawobj raw = {NULL}; - if ((error = pack_entry_find_prefix( - &e, (struct pack_backend *)backend, short_oid, len)) == 0 && - (error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0) + if ((error = pack_entry_find_prefix(&e, + backend, short_oid, len)) == 0 && + (error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0) { *buffer_p = raw.data; *len_p = raw.len; *type_p = raw.type; - git_oid_cpy(out_oid, &e.sha1); + git_oid_cpy(out_oid, &e.id); } } @@ -642,7 +648,7 @@ static int pack_backend__exists_prefix( struct git_pack_entry e = {0}; error = pack_entry_find_prefix(&e, pb, short_id, len); - git_oid_cpy(out, &e.sha1); + git_oid_cpy(out, &e.id); return error; } @@ -840,7 +846,10 @@ static void pack_backend__free(git_odb_backend *_backend) git__free(backend); } -static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) +static int pack_backend__alloc( + struct pack_backend **out, + size_t initial_size, + const git_odb_backend_pack_options *opts) { struct pack_backend *backend = git__calloc(1, sizeof(struct pack_backend)); GIT_ERROR_CHECK_ALLOC(backend); @@ -849,12 +858,19 @@ static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) git__free(backend); return -1; } + if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) { git_vector_free(&backend->midx_packs); git__free(backend); return -1; } + if (opts) + memcpy(&backend->opts, opts, sizeof(git_odb_backend_pack_options)); + + if (!backend->opts.oid_type) + backend->opts.oid_type = GIT_OID_DEFAULT; + backend->parent.version = GIT_ODB_BACKEND_VERSION; backend->parent.read = &pack_backend__read; @@ -873,17 +889,31 @@ static int pack_backend__alloc(struct pack_backend **out, size_t initial_size) return 0; } -int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx) +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_odb_backend_one_pack( + git_odb_backend **backend_out, + const char *idx, + const git_odb_backend_pack_options *opts) +#else +int git_odb_backend_one_pack( + git_odb_backend **backend_out, + const char *idx) +#endif { struct pack_backend *backend = NULL; struct git_pack_file *packfile = NULL; - if (pack_backend__alloc(&backend, 1) < 0) +#ifndef GIT_EXPERIMENTAL_SHA256 + git_odb_backend_pack_options *opts = NULL; +#endif + + git_oid_t oid_type = opts ? opts->oid_type : 0; + + if (pack_backend__alloc(&backend, 1, opts) < 0) return -1; - if (git_mwindow_get_pack(&packfile, idx) < 0 || - git_vector_insert(&backend->packs, packfile) < 0) - { + if (git_mwindow_get_pack(&packfile, idx, oid_type) < 0 || + git_vector_insert(&backend->packs, packfile) < 0) { pack_backend__free((git_odb_backend *)backend); return -1; } @@ -892,18 +922,30 @@ int git_odb_backend_one_pack(git_odb_backend **backend_out, const char *idx) return 0; } -int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir) +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_odb_backend_pack( + git_odb_backend **backend_out, + const char *objects_dir, + const git_odb_backend_pack_options *opts) +#else +int git_odb_backend_pack( + git_odb_backend **backend_out, + const char *objects_dir) +#endif { int error = 0; struct pack_backend *backend = NULL; git_str path = GIT_STR_INIT; - if (pack_backend__alloc(&backend, 8) < 0) +#ifndef GIT_EXPERIMENTAL_SHA256 + git_odb_backend_pack_options *opts = NULL; +#endif + + if (pack_backend__alloc(&backend, 8, opts) < 0) return -1; if (!(error = git_str_joinpath(&path, objects_dir, "pack")) && - git_fs_path_isdir(git_str_cstr(&path))) - { + git_fs_path_isdir(git_str_cstr(&path))) { backend->pack_folder = git_str_detach(&path); error = pack_backend__refresh((git_odb_backend *)backend); } diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c index d428729ea..c30801844 100644 --- a/src/libgit2/pack.c +++ b/src/libgit2/pack.c @@ -32,7 +32,7 @@ static int packfile_unpack_compressed( * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid * is ambiguous within the pack. * This method assumes that len is between - * GIT_OID_MINPREFIXLEN and GIT_OID_SHA1_HEXSIZE. + * GIT_OID_MINPREFIXLEN and the oid type's hexsize. */ static int pack_entry_find_offset( off64_t *offset_out, @@ -186,9 +186,9 @@ static int cache_add( static void pack_index_free(struct git_pack_file *p) { - if (p->oids) { - git__free(p->oids); - p->oids = NULL; + if (p->ids) { + git__free(p->ids); + p->ids = NULL; } if (p->index_map.data) { git_futils_mmap_free(&p->index_map); @@ -205,6 +205,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) size_t idx_size; struct stat st; int error; + /* TODO: properly open the file without access time using O_NOATIME */ git_file fd = git_futils_open_ro(path); if (fd < 0) @@ -218,8 +219,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) if (!S_ISREG(st.st_mode) || !git__is_sizet(st.st_size) || - (idx_size = (size_t)st.st_size) < 4 * 256 + 20 + 20) - { + (idx_size = (size_t)st.st_size) < (size_t)((4 * 256) + (p->oid_size * 2))) { p_close(fd); git_error_set(GIT_ERROR_ODB, "invalid pack index '%s'", path); return -1; @@ -242,8 +242,9 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) return packfile_error("unsupported index version"); } - } else + } else { version = 1; + } nr = 0; index = idx_map; @@ -264,11 +265,11 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) /* * Total size: * - 256 index entries 4 bytes each - * - 24-byte entries * nr (20-byte sha1 + 4-byte offset) - * - 20-byte SHA1 of the packfile - * - 20-byte SHA1 file checksum + * - 24/36-byte entries * nr (20/32 byte SHA + 4-byte offset) + * - 20/32-byte SHA of the packfile + * - 20/32-byte SHA file checksum */ - if (idx_size != 4*256 + nr * 24 + 20 + 20) { + if (idx_size != (4 * 256 + (nr * (p->oid_size + 4)) + (p->oid_size * 2))) { git_futils_mmap_free(&p->index_map); return packfile_error("index is corrupted"); } @@ -277,16 +278,16 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p) * Minimum size: * - 8 bytes of header * - 256 index entries 4 bytes each - * - 20-byte sha1 entry * nr + * - 20/32-byte SHA entry * nr * - 4-byte crc entry * nr * - 4-byte offset entry * nr - * - 20-byte SHA1 of the packfile - * - 20-byte SHA1 file checksum + * - 20/32-byte SHA of the packfile + * - 20/32-byte SHA file checksum * And after the 4-byte offset table might be a * variable sized table containing 8-byte entries * for offsets larger than 2^31. */ - unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20; + unsigned long min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2); unsigned long max_size = min_size; if (nr) @@ -365,12 +366,12 @@ static unsigned char *pack_window_open( * Don't allow a negative offset, as that means we've wrapped * around. */ - if (offset > (p->mwf.size - 20)) + if (offset > (p->mwf.size - p->oid_size)) goto cleanup; if (offset < 0) goto cleanup; - pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, 20, left); + pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, p->oid_size, left); cleanup: git_mutex_unlock(&p->mwf.lock); @@ -473,13 +474,13 @@ int git_packfile_unpack_header( return error; } - /* pack_window_open() assures us we have [base, base + 20) available - * as a range that we can look at at. (Its actually the hash - * size that is assured.) With our object header encoding - * the maximum deflated object size is 2^137, which is just - * insane, so we know won't exceed what we have been given. + /* pack_window_open() assures us we have [base, base + oid_size) + * available as a range that we can look at at. (It's actually + * the hash size that is assured.) With our object header + * encoding the maximum deflated object size is 2^137, which is + * just insane, so we know won't exceed what we have been given. */ - base = git_mwindow_open(&p->mwf, w_curs, *curpos, 20, &left); + base = git_mwindow_open(&p->mwf, w_curs, *curpos, p->oid_size, &left); git_mutex_unlock(&p->lock); git_mutex_unlock(&p->mwf.lock); if (base == NULL) @@ -977,11 +978,12 @@ int get_delta_base( /* Assumption: the only reason this would fail is because the file is too small */ if (base_info == NULL) return GIT_EBUFS; - /* pack_window_open() assured us we have [base_info, base_info + 20) - * as a range that we can look at without walking off the - * end of the mapped window. Its actually the hash size - * that is assured. An OFS_DELTA longer than the hash size - * is stupid, as then a REF_DELTA would be smaller to store. + /* pack_window_open() assured us we have + * [base_info, base_info + oid_size) as a range that we can look + * at without walking off the end of the mapped window. Its + * actually the hash size that is assured. An OFS_DELTA longer + * than the hash size is stupid, as then a REF_DELTA would be + * smaller to store. */ if (type == GIT_OBJECT_OFS_DELTA) { unsigned used = 0; @@ -1002,7 +1004,7 @@ int get_delta_base( *curpos += used; } else if (type == GIT_OBJECT_REF_DELTA) { git_oid base_oid; - git_oid__fromraw(&base_oid, base_info, GIT_OID_SHA1); + git_oid__fromraw(&base_oid, base_info, p->oid_type); /* If we have the cooperative cache, search in it first */ if (p->has_cache) { @@ -1012,7 +1014,7 @@ int get_delta_base( if (entry->offset == 0) return packfile_error("delta offset is zero"); - *curpos += 20; + *curpos += p->oid_size; *delta_base_out = entry->offset; return 0; } else { @@ -1025,9 +1027,9 @@ int get_delta_base( } /* The base entry _must_ be in the same pack */ - if (pack_entry_find_offset(&base_offset, &unused, p, &base_oid, GIT_OID_SHA1_HEXSIZE) < 0) + if (pack_entry_find_offset(&base_offset, &unused, p, &base_oid, p->oid_hexsize) < 0) return packfile_error("base entry delta is not in the same pack"); - *curpos += 20; + *curpos += p->oid_size; } else return packfile_error("unknown object type"); @@ -1070,7 +1072,7 @@ void git_packfile_free(struct git_pack_file *p, bool unlink_packfile) pack_index_free(p); - git__free(p->bad_object_sha1); + git__free(p->bad_object_ids); git_mutex_free(&p->bases.lock); git_mutex_free(&p->mwf.lock); @@ -1083,8 +1085,8 @@ static int packfile_open_locked(struct git_pack_file *p) { struct stat st; struct git_pack_header hdr; - unsigned char sha1[GIT_OID_SHA1_SIZE]; - unsigned char *idx_sha1; + unsigned char checksum[GIT_OID_MAX_SIZE]; + unsigned char *idx_checksum; if (pack_index_open_locked(p) < 0) return git_odb__error_notfound("failed to open packfile", NULL, 0); @@ -1131,12 +1133,13 @@ static int packfile_open_locked(struct git_pack_file *p) /* Verify the pack matches its index. */ if (p->num_objects != ntohl(hdr.hdr_entries) || - p_pread(p->mwf.fd, sha1, GIT_OID_SHA1_SIZE, p->mwf.size - GIT_OID_SHA1_SIZE) < 0) + p_pread(p->mwf.fd, checksum, p->oid_size, p->mwf.size - p->oid_size) < 0) goto cleanup; - idx_sha1 = ((unsigned char *)p->index_map.data) + p->index_map.len - 40; + idx_checksum = ((unsigned char *)p->index_map.data) + + p->index_map.len - (p->oid_size * 2); - if (git_oid_raw_cmp(sha1, idx_sha1, GIT_OID_SHA1_SIZE) != 0) + if (git_oid_raw_cmp(checksum, idx_checksum, p->oid_size) != 0) goto cleanup; if (git_mwindow_file_register(&p->mwf) < 0) @@ -1171,7 +1174,10 @@ int git_packfile__name(char **out, const char *path) return 0; } -int git_packfile_alloc(struct git_pack_file **pack_out, const char *path) +int git_packfile_alloc( + struct git_pack_file **pack_out, + const char *path, + git_oid_t oid_type) { struct stat st; struct git_pack_file *p; @@ -1219,6 +1225,9 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path) p->pack_local = 1; p->mtime = (git_time_t)st.st_mtime; p->index_version = -1; + p->oid_type = oid_type ? oid_type : GIT_OID_DEFAULT; + p->oid_size = (unsigned int)git_oid_size(p->oid_type); + p->oid_hexsize = (unsigned int)git_oid_hexsize(p->oid_type); if (git_mutex_init(&p->lock) < 0) { git_error_set(GIT_ERROR_OS, "failed to initialize packfile mutex"); @@ -1260,9 +1269,9 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t end = index + p->index_map.len; index += 4 * 256; if (p->index_version == 1) - return ntohl(*((uint32_t *)(index + 24 * n))); + return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * n))); - index += 8 + p->num_objects * (20 + 4); + index += 8 + p->num_objects * (p->oid_size + 4); off32 = ntohl(*((uint32_t *)(index + 4 * n))); if (!(off32 & 0x80000000)) return off32; @@ -1273,7 +1282,7 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t return -1; return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) | - ntohl(*((uint32_t *)(index + 4))); + ntohl(*((uint32_t *)(index + 4))); } static int git__memcmp4(const void *a, const void *b) { @@ -1312,7 +1321,7 @@ int git_pack_foreach_entry( index += 4 * 256; - if (p->oids == NULL) { + if (p->ids == NULL) { git_vector offsets, oids; if ((error = git_vector_init(&oids, p->num_objects, NULL))) { @@ -1326,22 +1335,25 @@ int git_pack_foreach_entry( } if (p->index_version > 1) { - const unsigned char *off = index + 24 * p->num_objects; + const unsigned char *off = index + + (p->oid_size + 4) * p->num_objects; + for (i = 0; i < p->num_objects; i++) git_vector_insert(&offsets, (void*)&off[4 * i]); + git_vector_sort(&offsets); git_vector_foreach(&offsets, i, current) git_vector_insert(&oids, (void*)&index[5 * (current - off)]); } else { for (i = 0; i < p->num_objects; i++) - git_vector_insert(&offsets, (void*)&index[24 * i]); + git_vector_insert(&offsets, (void*)&index[(p->oid_size + 4) * i]); git_vector_sort(&offsets); git_vector_foreach(&offsets, i, current) git_vector_insert(&oids, (void*)¤t[4]); } git_vector_free(&offsets); - p->oids = (unsigned char **)git_vector_detach(NULL, NULL, &oids); + p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids); } /* @@ -1362,7 +1374,7 @@ int git_pack_foreach_entry( git_array_clear(oids); GIT_ERROR_CHECK_ALLOC(oid); } - git_oid__fromraw(oid, p->oids[i], GIT_OID_SHA1); + git_oid__fromraw(oid, p->ids[i], p->oid_type); } git_mutex_unlock(&p->lock); @@ -1412,10 +1424,13 @@ int git_pack_foreach_entry_offset( /* all offsets should have been validated by pack_index_check_locked */ if (p->index_version > 1) { - const unsigned char *offsets = index + 24 * p->num_objects; + const unsigned char *offsets = index + + (p->oid_size + 4) * p->num_objects; const unsigned char *large_offset_ptr; - const unsigned char *large_offsets = index + 28 * p->num_objects; - const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - 20; + const unsigned char *large_offsets = index + + (p->oid_size + 8) * p->num_objects; + const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - p->oid_size; + for (i = 0; i < p->num_objects; i++) { current_offset = ntohl(*(const uint32_t *)(offsets + 4 * i)); if (current_offset & 0x80000000) { @@ -1428,7 +1443,7 @@ int git_pack_foreach_entry_offset( ntohl(*((uint32_t *)(large_offset_ptr + 4))); } - git_oid__fromraw(¤t_oid, (index + 20 * i), GIT_OID_SHA1); + git_oid__fromraw(¤t_oid, (index + p->oid_size * i), p->oid_type); if ((error = cb(¤t_oid, current_offset, data)) != 0) { error = git_error_set_after_callback(error); goto cleanup; @@ -1436,8 +1451,8 @@ int git_pack_foreach_entry_offset( } } else { for (i = 0; i < p->num_objects; i++) { - current_offset = ntohl(*(const uint32_t *)(index + 24 * i)); - git_oid__fromraw(¤t_oid, (index + 24 * i + 4), GIT_OID_SHA1); + current_offset = ntohl(*(const uint32_t *)(index + (p->oid_size + 4) * i)); + git_oid__fromraw(¤t_oid, (index + (p->oid_size + 4) * i + 4), p->oid_type); if ((error = cb(¤t_oid, current_offset, data)) != 0) { error = git_error_set_after_callback(error); goto cleanup; @@ -1450,14 +1465,20 @@ cleanup: return error; } -int git_pack__lookup_sha1(const void *oid_lookup_table, size_t stride, unsigned lo, - unsigned hi, const unsigned char *oid_prefix) +int git_pack__lookup_id( + const void *oid_lookup_table, + size_t stride, + unsigned lo, + unsigned hi, + const unsigned char *oid_prefix, + const git_oid_t oid_type) { const unsigned char *base = oid_lookup_table; + size_t oid_size = git_oid_size(oid_type); while (lo < hi) { unsigned mi = (lo + hi) / 2; - int cmp = git_oid_raw_cmp(base + mi * stride, oid_prefix, GIT_OID_SHA1_SIZE); + int cmp = git_oid_raw_cmp(base + mi * stride, oid_prefix, oid_size); if (!cmp) return mi; @@ -1512,9 +1533,9 @@ static int pack_entry_find_offset( lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(level1_ofs[(int)short_oid->id[0] - 1])); if (p->index_version > 1) { - stride = 20; + stride = p->oid_size; } else { - stride = 24; + stride = p->oid_size + 4; index += 4; } @@ -1523,7 +1544,8 @@ static int pack_entry_find_offset( short_oid->id[0], short_oid->id[1], short_oid->id[2], lo, hi, p->num_objects); #endif - pos = git_pack__lookup_sha1(index, stride, lo, hi, short_oid->id); + pos = git_pack__lookup_id(index, stride, lo, hi, + short_oid->id, p->oid_type); if (pos >= 0) { /* An object matching exactly the oid was found */ @@ -1541,7 +1563,9 @@ static int pack_entry_find_offset( } } - if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)p->num_objects) { + if (found && + len != p->oid_hexsize && + pos + 1 < (int)p->num_objects) { /* Check for ambiguousity */ const unsigned char *next = current + stride; @@ -1566,13 +1590,13 @@ static int pack_entry_find_offset( } *offset_out = offset; - git_oid__fromraw(found_oid, current, GIT_OID_SHA1); + git_oid__fromraw(found_oid, current, p->oid_type); #ifdef INDEX_DEBUG_LOOKUP { - unsigned char hex_sha1[GIT_OID_SHA1_HEXSIZE + 1]; + char hex_sha1[p->oid_hexsize + 1]; git_oid_fmt(hex_sha1, found_oid); - hex_sha1[GIT_OID_SHA1_HEXSIZE] = '\0'; + hex_sha1[p->oid_hexsize] = '\0'; printf("found lo=%d %s\n", lo, hex_sha1); } #endif @@ -1594,10 +1618,10 @@ int git_pack_entry_find( GIT_ASSERT_ARG(p); - if (len == GIT_OID_SHA1_HEXSIZE && p->num_bad_objects) { + if (len == p->oid_hexsize && p->num_bad_objects) { unsigned i; for (i = 0; i < p->num_bad_objects; i++) - if (git_oid__cmp(short_oid, &p->bad_object_sha1[i]) == 0) + if (git_oid__cmp(short_oid, &p->bad_object_ids[i]) == 0) return packfile_error("bad object found in packfile"); } @@ -1630,6 +1654,6 @@ int git_pack_entry_find( e->offset = offset; e->p = p; - git_oid_cpy(&e->sha1, &found_oid); + git_oid_cpy(&e->id, &found_oid); return 0; } diff --git a/src/libgit2/pack.h b/src/libgit2/pack.h index d90588f79..1a9eb14b2 100644 --- a/src/libgit2/pack.h +++ b/src/libgit2/pack.h @@ -99,13 +99,19 @@ struct git_pack_file { uint32_t num_objects; uint32_t num_bad_objects; - git_oid *bad_object_sha1; /* array of git_oid */ + git_oid *bad_object_ids; /* array of git_oid */ + + git_oid_t oid_type; + unsigned oid_hexsize:7, + oid_size:6, + pack_local:1, + pack_keep:1, + has_cache:1; int index_version; git_time_t mtime; - unsigned pack_local:1, pack_keep:1, has_cache:1; git_oidmap *idx_cache; - unsigned char **oids; + unsigned char **ids; git_pack_cache bases; /* delta base cache */ @@ -116,21 +122,26 @@ struct git_pack_file { }; /** - * Return the position where an OID (or a prefix) would be inserted within the - * OID Lookup Table of an .idx file. This performs binary search between the lo - * and hi indices. + * Return the position where an OID (or a prefix) would be inserted within + * the OID Lookup Table of an .idx file. This performs binary search + * between the lo and hi indices. * - * The stride parameter is provided because .idx files version 1 store the OIDs - * interleaved with the 4-byte file offsets of the objects within the .pack - * file (stride = 24), whereas files with version 2 store them in a contiguous - * flat array (stride = 20). + * The stride parameter is provided because .idx files version 1 store the + * OIDs interleaved with the 4-byte file offsets of the objects within the + * .pack file (stride = oid_size + 4), whereas files with version 2 store + * them in a contiguous flat array (stride = oid_size). */ -int git_pack__lookup_sha1(const void *oid_lookup_table, size_t stride, unsigned lo, - unsigned hi, const unsigned char *oid_prefix); +int git_pack__lookup_id( + const void *id_lookup_table, + size_t stride, + unsigned lo, + unsigned hi, + const unsigned char *id_prefix, + const git_oid_t oid_type); struct git_pack_entry { off64_t offset; - git_oid sha1; + git_oid id; struct git_pack_file *p; }; @@ -174,12 +185,15 @@ int get_delta_base( off64_t delta_obj_offset); void git_packfile_free(struct git_pack_file *p, bool unlink_packfile); -int git_packfile_alloc(struct git_pack_file **pack_out, const char *path); +int git_packfile_alloc( + struct git_pack_file **pack_out, + const char *path, + git_oid_t oid_type); int git_pack_entry_find( struct git_pack_entry *e, struct git_pack_file *p, - const git_oid *short_oid, + const git_oid *short_id, size_t len); int git_pack_foreach_entry( struct git_pack_file *p, diff --git a/tests/libgit2/odb/foreach.c b/tests/libgit2/odb/foreach.c index 165a511a0..56b3e882c 100644 --- a/tests/libgit2/odb/foreach.c +++ b/tests/libgit2/odb/foreach.c @@ -52,7 +52,16 @@ void test_odb_foreach__one_pack(void) int nobj = 0; cl_git_pass(git_odb__new(&_odb, NULL)); - cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"), + NULL)); +#else + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#endif + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); _repo = NULL; diff --git a/tests/libgit2/odb/pack_data_one256.h b/tests/libgit2/odb/pack_data_one256.h new file mode 100644 index 000000000..98a874798 --- /dev/null +++ b/tests/libgit2/odb/pack_data_one256.h @@ -0,0 +1,21 @@ +/* Just a few to make sure it's working, the rest is tested already */ +#ifdef GIT_EXPERIMENTAL_SHA256 +static const char *packed_objects_one256[] = { + "ea926306b1bab6d3f25f45609907eb6dff91a1460b25e63bf4a0494c70e7a269", + "d048ba2ef4fafa502a44cbc1a50cd58359b9bc243b84a08f541a08ca5f621137", + "a66bda0109d2b3c9bc87970da81bd91076b5f871febbc860f09ae997668b6800", + "3609a41c0506fe19d01fb8b4729923362675f191fe5f63fab3111ef804c48fdf", + "22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570", + "6f11d93bfb269ee8c7a506178f60c430abfac5d424acfd9c0b0b27b98e6ab49b", + "0aefd477d9e5b3f8d708a3cf6d78be6b670dfa2e2ec41244634f3b8f115d8e04", + "580474d948cd2ebd2e5ce7a5b81b872d87ba4639c1ac4c0fa7a11a8eddf9827c", + "0636b4292bfdd7274a977cb6f8b2ded8f315ea1bcd8dbedfca37964c2ed3d085", + "19fb1c78b11f0f8bda658d6fa6cc63c0b573c0f6760ee5a9c2df6ce2cde00c5c", + "7f2f7afccb317bb3fdd28555f126846dc4eebe5d9ae7b8d8a1456e8ff85422ce", + "4066249c68b0d3c8b39ebe02c9188935900465acad02a49269710f56720fa58e", + "a560d1fa1edf114f57b402e16d662c17b1e3b7e8601ff7dcea6615ba7f1e48ef", + "58923faa87c7d559d308a114ec2b164e5d6046c889420ed1def6eef2d55106a2", + "753ddabab8ae9c1e733cda15e8e3c83dd43f5a2d939ae32cc3b30b0be1e91f96", + "46333d32b3801cf11d9f80b557245c9e32b0e05deca61dae968914fde159f0e5" +}; +#endif diff --git a/tests/libgit2/odb/packedone.c b/tests/libgit2/odb/packedone.c index 9af27e8c7..8637001ff 100644 --- a/tests/libgit2/odb/packedone.c +++ b/tests/libgit2/odb/packedone.c @@ -11,7 +11,14 @@ void test_odb_packedone__initialize(void) git_odb_backend *backend = NULL; cl_git_pass(git_odb__new(&_odb, NULL)); - cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"), + NULL)); +#else + cl_git_pass(git_odb_backend_one_pack(&backend, + cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"))); +#endif cl_git_pass(git_odb_add_backend(_odb, backend, 1)); } diff --git a/tests/libgit2/odb/packedone256.c b/tests/libgit2/odb/packedone256.c new file mode 100644 index 000000000..fdeac4205 --- /dev/null +++ b/tests/libgit2/odb/packedone256.c @@ -0,0 +1,78 @@ +#include "clar_libgit2.h" +#include "git2/odb_backend.h" + +#include "pack_data_one256.h" +#include "pack.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_odb *_odb; +#endif + +void test_odb_packedone256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_backend *backend = NULL; + git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT; + git_odb_backend_pack_options backend_opts = GIT_ODB_BACKEND_PACK_OPTIONS_INIT; + + odb_opts.oid_type = GIT_OID_SHA256; + backend_opts.oid_type = GIT_OID_SHA256; + + cl_git_pass(git_odb__new(&_odb, &odb_opts)); + cl_git_pass(git_odb_backend_one_pack( + &backend, + cl_fixture("testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx"), + &backend_opts)); + cl_git_pass(git_odb_add_backend(_odb, backend, 1)); +#endif +} + +void test_odb_packedone256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_free(_odb); + _odb = NULL; +#endif +} + +void test_odb_packedone256__mass_read(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one256); ++i) { + git_oid id; + git_odb_object *obj; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256)); + cl_assert(git_odb_exists(_odb, &id) == 1); + cl_git_pass(git_odb_read(&obj, _odb, &id)); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packedone256__read_header_0(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_one256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256)); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} diff --git a/tests/libgit2/odb/sorting.c b/tests/libgit2/odb/sorting.c index 1010872f4..ec4e3696b 100644 --- a/tests/libgit2/odb/sorting.c +++ b/tests/libgit2/odb/sorting.c @@ -82,7 +82,11 @@ void test_odb_sorting__override_default_backend_priority(void) cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_LOOSE_PRIORITY, 5)); cl_git_pass(git_libgit2_opts(GIT_OPT_SET_ODB_PACKED_PRIORITY, 3)); - git_odb_backend_pack(&packed, "./testrepo.git/objects"); + git_odb_backend_pack(&packed, "./testrepo.git/objects" +#ifdef GIT_EXPERIMENTAL_SHA256 + , NULL +#endif + ); git_odb__backend_loose(&loose, "./testrepo.git/objects", NULL); cl_git_pass(git_odb__open(&new_odb, cl_fixture("testrepo.git/objects"), NULL)); diff --git a/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx b/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.idx new file mode 100644 index 0000000000000000000000000000000000000000..7aa472ceaeabd319cd129414f9d72cdefa6b15a9 GIT binary patch literal 1376 zcmexg;-AdGz`z8=ga9K@!BD~=KT!)a1ILfD5l z=wib$S;lix6Ym{;7xCfrv-qo1jMuGTUOlNY)zkj^q9q2ulQ&KIk+I(I+nJMxU#RAp zb3~pC?^15AIuUICHR-GA^~l&*zPMoS*w-c@I@3JmUm0)-OE70A1ha+oY*PJ^6zBZ& zfxn8TeEHdZK82ePE#AOjpWry#?m`x8Z&^QqeU|I*td8~HV4`n2+26M97n|9+kDb2(r97Xp literal 0 HcmV?d00001 diff --git a/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack b/tests/resources/packfile-sha256/pack-b4a043c0ec5e079e8ac67d823776d752efc71661592db317474a0cf292915f31.pack new file mode 100644 index 0000000000000000000000000000000000000000..adbe70ad35af897528d8ad69f89907a4479859b7 GIT binary patch literal 1406 zcmV-^1%didK|@Ob00062000NENqC%vQ^8K-Fc7`(SIlu2Wr4EVQ%?a=hy-nwq(VKq z@q~RYvW#doWtZsXp{wy znnLun8zYxRP*$Hg553dWPC~+Gqt)mkb_fxDAHcQg=VrNq8?@+^f%UjE)W97zXai>O zj6RUFaFGdz3NT1P=upFMO6Y~?sSbKz;kb#43^`?hUR{lKniVK@$wW`48NayeJ+$R^DJ_7ppC z4E8X1_vlq0UMII&s6TkjVgmjPcB6Pd@jj%okqg0d9oa`-p6ipek+C18oC18W#fMKl z5QYzg0ki`(3}zDhUe)sTfK3c@XnF1UqWZz`{`hX<<~+S{q%=^Ip!^nJuFW8Jx?O6Sf!?OQM>bqI`xaQ6c;+%>S$2}PXyW~YXnhdy7 zI39}ncD1P?UvA+cFUx#cZ|85`;xoQd5f4br%(3&z#);<<^!;^tb<2?avbZbiEwCAj zqF!EC6)aXICLG5`C5h$4f%Pg3_iR;7aNYrGMPeNUp7z(FN{jPz zQyDmHw7Xrx94;003Yd*??mr7E>V z5)~;^x3yH7l0Q(4DkpCCJnb3Z+ppT=EbTT;UUL-{P_xFLXygjdbdwe}*&X zb#s=yt>K~EhHb8QIa7jHc!#%LUJmyknq46VDn=Iwb_V9fdrT{1w}C)MvqH3xhvV*P zp0TILZ4Vh;aG?jgr0pXC-KP-)W)}ndp{6BGai$|=z|hkSF60!=(vbnZ{)#^__Tl(k$LurGKXdtS;Hc$`&F+fKwF5Pjz>=3TdGp%=Q@7>&=y2iFgn(t%=HXec$? zzn8kZiIPb;Gt9Z*yDw4^kYg!w-PNMwZK-7~QJ17^rBtf~NnX_?np{?`qN4Z#KpRPuHacpXq|rJW`e>Pf&2)$fD$J z0}pvRjGYI&K&m(p?2`T(Rr>&eM#6>eE;nOX)@j19?Nox!_ZxWqOTWEOv@B@oG4(E@ zb=DcsYe*Xb=rWJ!Fk0`}jWw@f_Q~ZgGN3b*BDolRzbfjX+y2OBjD1++s6Tjp=(Z!g zz$cuC6!(N{O!vPJvmeaAd%ZGvoJ-^a007PaY_y<5!0cWJo{GkOf;V>8Qt!tWVOcG+ M7e`7A@{*BXG4>I-djJ3c literal 0 HcmV?d00001 From 6204499242101d0f93cd7e56e259c900828e41e1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Mon, 25 Jul 2022 13:04:08 -0400 Subject: [PATCH 10/22] odb: test sha256 pack backend --- tests/libgit2/odb/pack_data_256.h | 154 ++++++++++++++++++++++++++++++ tests/libgit2/odb/packed256.c | 98 +++++++++++++++++++ 2 files changed, 252 insertions(+) create mode 100644 tests/libgit2/odb/pack_data_256.h create mode 100644 tests/libgit2/odb/packed256.c diff --git a/tests/libgit2/odb/pack_data_256.h b/tests/libgit2/odb/pack_data_256.h new file mode 100644 index 000000000..b63188227 --- /dev/null +++ b/tests/libgit2/odb/pack_data_256.h @@ -0,0 +1,154 @@ +#ifdef GIT_EXPERIMENTAL_SHA256 + +static const char *packed_objects_256[] = { + "99f3b405443221141eb0fd1e0cca5d355f893983749b7fb455769fba434e7945", + "d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d", + "86e228d9904af64586e9a8378005ba654681ff5be3c43ca930bf6b1f28d4395f", + "652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b", + "ad90f638cb67720b20b904478471504acebacc7bb36e5dcad3e882acec496fed", + "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744", + "80ec1e36b983e68664e8357c538cd35b30638bb0cb99626f906d145e2d2e2558", + "e8bbf40ee280bc43b33c04df2250903b75e92f2497e91759cf1cad753c23be6c", + "8864b5746d7c5780083bb98449a3f5bf78d8281e8c5e3fd12a8ccd9103eb3a1f", + "083c2b8b445640d171e7aa667b0b32007006f786711032ebb82931cca69cc15b", + "5c8bea399f78d3d6a037a41cee2e763d00024180b66f2ec738d443b6a3dd7081", + "281c36286eab5e534f1c2121a4cf2cd48a32b3773a3e78df500bed3f3c9747f3", + "c9dc53358a0d83bee1caae40ee81d752abf4962a9f206702e24a447b766b5bd7", + "fafc05a1d0b7614ba32f428eb52f3439ffbfed9a817e5ae069364cfc3fa3e4d4", + "25a4efebb38c55b8f2309ce5e3116b2b9287239952cc2fa174074e05c6e5875a", + "c223f1b579bad18635efdeffa7a8ff40567d03fa427e08bb90d9878f958d8021", + "8a0042d434a2f8a2e8d47caa4eb454f388752fb3fe71150c1cea12e807cfdf1c", + "d79e913b4137117b7f8fc2a8d184373f657d6f71bbeaca0fe83b7757ce486108", + "375f69d3d41e36d6904bfa86221690ec49de2a030664a362abaf86c426f9f7e0", + "22b6705b86e4aa9120eff203af24709d483698d9f78695e86e82de121784b570", + "4516b0e63349c81abc6584cb11ce84ab8ba38b105f9de39d0d0a1455dba2478d", + "c2b535bfc3501f0b4e179d5d6f0e2cea613940fa3813be5923db7e71e190849f", + "aa793f0e9d9d746eba8a7a60cb4981f7e24ce9691910350d7df9b9e94c7567b9", + "890bb959ac8c20db603bf083bc82f55f9f42b6dca6581d941d0b361188abae3b", + "bfc0ee6fe04854c11011539f38cc6b9b73e0c445bac2008de2fb877123efc2e3", + "5ba7253f47d390ee2c7c7afe8fd9a963a7a2674bbdadeb9a927665c9246306c4", + "79bc735b91f8dfa9379d1d6c21e2d519ac1bf0d04d48534864c9ff571df5297d", + "f362826c827aa3bcbeb3ff8b71bba08d7440b89ab53fe95d61b8922d01f46e28", + "4a1b9c078e7bb20759a2d75e3a4b96827c851446c0261750b96aa5f286efe378", + "2e2aa456dbbb8889923eb6713672427854020298a764967c50235a9a76d7ce4b", + "97b0e3661fa0caa6200c50381233f8320b907540ceb9d17ac94fedc66fd093c2", + "ade7d297ede7bb58008da582de1253f0a55cb76e82d1cd376f82ccf97f70bced", + "3315093132a8f28bd202c0a9562d04eebea4943dcd1e1c754341b0389722042f", + "6fae137ba81d0d81c2a85759b99322e7ea8103bd7c8b85be3163b7e91e18c125", + "f8b45f792840019909fd35f9dcb98082b3bc39373268d467e1b00f1da5ac71e5", + "d2ab425d6092770366bc3dff5276e3a869221bc7b6d22e99c089d556e7eb8331", + "4dd37b9df07bcc7b45ce72a44e3f5fcaf5f0a9a5f3148963714eac4c99a60388", + "8c53c0f9f0972a1c77e40549170b9ae51d365c200ffc4cb220628c5bce3dd0b2", + "11d0463a82345c2512bd704dd00211aefb7d5b8590ca92809122fd09486a9f06", + "1ab4fa663d22416f45cb1a007d767a58d0abf5255bf86f888393dae637b37c3b", + "345d2fbf1d306c7ea46a05f497793308357e9e17ab0e866446d2b9894378ddce", + "304352ddad641770fcc94ee4d9f957cde7aaf4c107dbf8b5ba14d543640bf7dd", + "cfdd565f4cbc315760c287d57714852e1a4894eef9c715332fd556f2e114a9f1", + "d6d2e87e6de8690efd26b8c5b58de28dcb3c9bd2b7659eccf34468d71a7a4478", + "aa61d4adf622265ec814c1a97198d2bcd3f58fb08989cb9beda32a4d0aab6697", + "40799f33b8cd9ca41f36a2f89d8ac8550537ad01dfb21fbc76f01eeb62f512d4", + "faa7ca59426e17f6b34fa407d06cd634faaabeb4abe26df12296e05a17c98eef", + "1f6ea2cab887a2ff4bb1557a36dd6bac9931ef1f36794ddd22b4b7b7276051fb", + "b38a7a2ee69d55f021efa91caf59e23bccdaf6b8a9c3f83acd978aa177587537", + "f66691f32eb9b23a029b43251bfa994d16481fe97903057e121b76e4e78f6ff4", + "afe1fad6f6b22eea530ff7b373d6b9b787b39792f720e6fcd0692ba6ef99e02f", + "b71ee6c8837efa5b3ba3361f88c321d391ac05f41d5b2506cad39319e80716e4", + "e207a266e228414023223530eb77c64b10f2f5124f3354deb45aff04c1db98b9", + "696503760a18787240ba52ad1abec3be6517bb802238e9469b3a8999cbd6432c", + "c30d06fd49797e3135652d654db0de122dd83f8400df1c7a0e95ca3720defb0d", + "8a9b600a21987e6ffddbad745f38c115797eacef9117043bd9d2da4835ee3cc4", + "d509fa76ff5944e25f48c2476736b6239a53f0463cba6ebc488464d087951951", + "3e00d8cae2726dc33879adf876b30c306f50e7a85b15c8add4a27f84d88616d7", + "ce55f9f5ab1d799a9ffaa839539af196d13f35677b3d0761b0fe034e764f8d07", + "84005e38a65f4115d5c94790010dc57e1a3297f4aa89744f5927f208af758bd0", + "75b0ed5f4a2d5c810f34d867dbca51db6a596d4739abfaf24fcc0f05d99097a8", + "3eab74a6894d790767f3d92615a6887dcccaffa9e48fdd2ce482b5f17efcf9b9", + "8e61988c998c96a131cfe72225fce43e555bec4e590fa8c239373172a9d485ce", + "5f45a18f90f2934e7c7985d05b2b5b3584886fd057c9202f26f562d6c3080038", + "7609c608c1097270356a6fe336a8756ff124d4a9c2e941bba26a6e8c3becdeb1", + "81ba4e67aa59ccb078e3dc9ff3075f50084ec1696bd867e8e4284fcfc34fe3cf", + "3b1b991ae70d1f5388ad16b63d2285e99ada7a618c6f5d01e50a6d4b33c4767d", + "ac49410f64fad10760838866a40107573e42c86908c83ece433d64b7a8b57f7f", + "72c472319cf7d5d59bf9fea9e90b9785d7ab39340003fbc68619c11a9e583c2f", + "3a0cd33a47fcd0c7b8f8c1d407aaa53f648e25f2ffe2533a7e9c09c3d1b9da75", + "bf409f1aa76256282ebf1a7cc6c9f4220be9ffc47b2cc42248fcc5cbb67bce1f", + "13c8c9dae9fa63b1ec48b8abb12312fc8df61b9414678f504fa68164a48eef28", + "078baf54914fab56842798c90fec863f15f67a22041e8aa54a88c43f059da050", + "41c166c241a4e878f444932a193501e12ab38ba0634747291df70e619dccee1c", + "9db520a5a88c7d75b86a4faa1ce9010edf38af922f400c69a4a93aef69e25c4c", + "edf6e0dbfaf8a7ad89b05b5768981eeedd7a2bda4b1d0fae07aa2a9d49bb39df", + "ec1866b39026366e69ab8e167c15312c27f5eda4c0afdf9367ac3d76f56bf8e7", + "695bdb545f636d454b4825effd29db96c46d81772dda6c104f97dffe2ec509f1", + "07c31b4be5f3ec8f82c7ad6c91cbdf07ae876bb73041903d64fe8bac64bbcb6e", + "06665948a581e547ac1dc883b35bab54682fc311f7a87d5563a76501ecba55fc", + "fa6a2b7e588e57115d2772c0d5250d886757404fc510a5956be8de4926e94c01", + "28aec9a4450d9de98db98a021f97026bf12f1328f66e53319669eb5adce5ed3e", + "290d84a2cf108c074d3764ca8dc56e1215a5a7482837f098dff7a55e23d89d5f", + "ed10f9520d5f0d6bbd9c467ed83a239df0cba94ae9031602e02f6ad6256c459e", + "ad05c66a177f844f8239a1d186a1f803a4daa6286c959538838e222bc6337dc9", + "88fecc715077807bd7ee9e6a1dff65fde000379e0bf2a15cc2404469cef4c82b", + "bcc4fa242e55c5e08f64900407dca1cf2451806830905be616f339bf7a5580aa", + "4a4ebb837e3c9883f35d0ecdc26d4bc76a0f665568b08f3e967096f2fd3fa537", + "9abb7801e72353060a1490ffa3331674d6882558e7d6458de397b4b00d31ff8c", + "466cdfec4c74f3ed4fe53165e468a52df5dff9c6533ec433cdf235a73e099d32", + "8a1e1a6cc00519c4df8ce404c987751446fa299662308622cb63576fb52996d7", + "e5ea38108d603a6ed8dbb0b8455abe6d971f2d60920207e67ba646d267ece305", + "97e00ba4c8028ea91e7131c8c7596227cd03d3d2d14ed2d179fe0f305ebbca39", + "807faa3586b7f1aff2797a7c39c135b0196647c9ae7ee8843322accc960b2f22", + "b9134c331629e9cb29d1bbc03904d911a942b451e087543fc16deb0116391297", + "23cb97c200205dc84109c248be5bd719c23bdab52b52c51ec92fef9a48790833", + "b6e8427e3afe1cf0095d0f5aeca0642c4fb12d4e529f62e8264b6c4db72f04b4", + "92128dfb792caea934f5218807ec993867b0c8487a3de69ebac33e067f64d38a", + "a13ecbc514b571721a9a1c92af7f89d473a5fe13228904f8d17368e71f273ea1", + "3f5dca26a2f512d6681ce1957b8afba5e031bf63d52fd52d8f57093bf92391a4", + "1aa24b7ebd910f39a676f2ccab8e9a79f14842c20b55ed18e3dc297bdbaca279", + "1e0ce38d00e8f3e613febc0f8b275e0fd7fbef8af293fd62698be46dfbbc937d", + "dd9b1d5ca653752cef167e034324198971ab6f2f38f3db9db571cb2985759f00", + "efc4b8fd4b0b2586fce256b107ee2a052d11d26f99d85ce0478c3d49d1b2186b", + "da38f65b32fb03ce332e0c4238edae0a733e4cd793d849522bb4e0bdd0af608c", + "bf66badfda7b5d2157db65c5310cfdc4e904d7d5da57ac5abe17542de612f856", + "2c0f52f9ae1f34f280dfc1c755cbfaf2b9968fd3bab1f1eb16d3ac0fafd71940", + "165ec90aa4190bbe12ee415b294fd6d204c64afcf1ca64dd815782872b24ea26", + "cc3d272d457c7e26c5d611923841511a1766bcd58e5be66433698627e6fb3f9d", + "d970d1a6296d149bfb8283b8b4a9a6f7e9ee320c5d46a5ef216e10400df2d281", + "bdc530e0b98dd736cd812408eeed9aa0d393bbd0630b355eb7601e61f0dbc7c4", + "94db24aca3f8e07f481744f62633730feb4fc47605280381a08be510ae971ffe", + "151c7527acc5b731199a03a932ae374331e16e5ae29256e98cb652f37669889b", + "ac88849a26c126b03fc6fcb17cb23ec563e87a5f63b7afe800ad0f436128ce98", + "26a2dac21f8f0939566570e48f7f4fcf89239c2746ef8d3dbf31d179c691808f", + "619f24a7f37f8ca922c83b3a1b9a384eb6a444ff3a2a52c712f3c60dde6f24fb", + "5329dd2fd8557be5ad06b57882cf42e23d767cdc8a4b25e464fdb00890649e07", + "fff5cbc10ffea865d69aba64082ae17479c522e8e0305e678469749282bf0a18", + "d0c992aae9cde855b17ac826234a73255ecb09534cdcfa633d90640f6a4324d9", + "6129f1672465ee7b9e2edef53fbf3846ab5d06e8e6a1d7fb51e31666a8b411f8", + "0a8c0add81b065b97451f7b47a9935f0e240251c5f90a89ced885cb7d4efc2ba", + "471fa4fc2da467dd94e57babb1912bbdb5e40b96c8129d46fc709c0bfc009bca", + "23cea2b49eed4993c5b92a9d5f0b82efe4fae3837ea707d921de645d04479015", + "c85e35eec23dea4089aee7a2dc7f6d937ad7e13c66bdbd7eef37bd6336418609", + "a0f3dac8fa0e22dcf356aecbbdf79440715687c1053bc59b83354f276d688ceb", + "1cfb8ae71e9e576d1b16b7bd1a62156d0641c6e51f5d76877be6de4f26410623" +}; + +static const char *loose_objects_256[] = { + "96c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045", + "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", + "73b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6", + "901505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724", + "4bc142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5", + "7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f", + "473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813", + "7030f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7", + "cb282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0", + "33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8", + "8155958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf", + "1b4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24", + "f31459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562", + "6d5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3", + "b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022", + "61489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e", + "abee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640", + "a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95", + "43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b" +}; + +#endif diff --git a/tests/libgit2/odb/packed256.c b/tests/libgit2/odb/packed256.c new file mode 100644 index 000000000..65220fd4c --- /dev/null +++ b/tests/libgit2/odb/packed256.c @@ -0,0 +1,98 @@ +#include "clar_libgit2.h" +#include "odb.h" +#include "pack_data_256.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_odb *_odb; +#endif + +void test_odb_packed256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_options opts = GIT_ODB_OPTIONS_INIT; + + opts.oid_type = GIT_OID_SHA256; + + cl_git_pass(git_odb__open( + &_odb, + cl_fixture("testrepo_256.git/objects"), + &opts)); +#endif +} + +void test_odb_packed256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + git_odb_free(_odb); + _odb = NULL; +#endif +} + +void test_odb_packed256__mass_read(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256)); + cl_assert(git_odb_exists(_odb, &id) == 1); + cl_git_pass(git_odb_read(&obj, _odb, &id)); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packed256__read_header_0(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(packed_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256)); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} + +void test_odb_packed256__read_header_1(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(loose_objects_256); ++i) { + git_oid id; + git_odb_object *obj; + size_t len; + git_object_t type; + + cl_git_pass(git_oid__fromstr(&id, loose_objects_256[i], GIT_OID_SHA256)); + + cl_assert(git_odb_exists(_odb, &id) == 1); + + cl_git_pass(git_odb_read(&obj, _odb, &id)); + cl_git_pass(git_odb_read_header(&len, &type, _odb, &id)); + + cl_assert(obj->cached.size == len); + cl_assert(obj->cached.type == type); + + git_odb_object_free(obj); + } +#endif +} + From fe2ee3a018286b04cd0c64f84d437c7317c8f138 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 05:09:46 -0400 Subject: [PATCH 11/22] object: lookup sha256 objects This is much of the plumbing for the object database to support SHA256, and for objects to be able to parse SHA256 versions of themselves. --- examples/index-pack.c | 9 +- fuzzers/objects_fuzzer.c | 2 +- fuzzers/packfile_fuzzer.c | 9 +- include/git2/indexer.h | 29 +++ include/git2/object.h | 30 ++- src/cli/cmd_hash_object.c | 32 ++- src/libgit2/blob.c | 6 +- src/libgit2/blob.h | 4 +- src/libgit2/commit.c | 57 ++++-- src/libgit2/commit.h | 34 +++- src/libgit2/commit_list.c | 6 +- src/libgit2/indexer.c | 79 +++++--- src/libgit2/object.c | 45 +++-- src/libgit2/object.h | 3 +- src/libgit2/odb_pack.c | 18 +- src/libgit2/pack-objects.c | 13 +- src/libgit2/repository.c | 5 +- src/libgit2/tag.c | 25 ++- src/libgit2/tag.h | 4 +- src/libgit2/tree.c | 38 ++-- src/libgit2/tree.h | 4 +- tests/libgit2/commit/parse.c | 2 +- tests/libgit2/object/commit/parse.c | 298 +++++++++++++++++++++++++--- tests/libgit2/object/lookup256.c | 153 ++++++++++++++ tests/libgit2/object/tag/parse.c | 4 +- tests/libgit2/object/tree/parse.c | 4 +- tests/libgit2/object/validate.c | 158 ++++++++++++--- tests/libgit2/pack/indexer.c | 53 ++++- tests/libgit2/pack/packbuilder.c | 17 ++ 29 files changed, 964 insertions(+), 177 deletions(-) create mode 100644 tests/libgit2/object/lookup256.c diff --git a/examples/index-pack.c b/examples/index-pack.c index df37dd0c4..0f8234c75 100644 --- a/examples/index-pack.c +++ b/examples/index-pack.c @@ -28,11 +28,18 @@ int lg2_index_pack(git_repository *repo, int argc, char **argv) return EXIT_FAILURE; } - if (git_indexer_new(&idx, ".", 0, NULL, NULL) < 0) { +#ifdef GIT_EXPERIMENTAL_SHA256 + error = git_indexer_new(&idx, ".", git_repository_oid_type(repo), NULL); +#else + error = git_indexer_new(&idx, ".", 0, NULL, NULL); +#endif + + if (error < 0) { puts("bad idx"); return -1; } + if ((fd = open(argv[1], 0)) < 0) { perror("open"); return -1; diff --git a/fuzzers/objects_fuzzer.c b/fuzzers/objects_fuzzer.c index 51b4a1ed4..7294e9b35 100644 --- a/fuzzers/objects_fuzzer.c +++ b/fuzzers/objects_fuzzer.c @@ -39,7 +39,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) * to do. */ for (i = 0; i < ARRAY_SIZE(types); i++) { - if (git_object__from_raw(&object, (const char *) data, size, types[i]) < 0) + if (git_object__from_raw(&object, (const char *) data, size, types[i], GIT_OID_SHA1) < 0) continue; git_object_free(object); object = NULL; diff --git a/fuzzers/packfile_fuzzer.c b/fuzzers/packfile_fuzzer.c index 52a813760..aeba9575c 100644 --- a/fuzzers/packfile_fuzzer.c +++ b/fuzzers/packfile_fuzzer.c @@ -67,6 +67,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) git_str path = GIT_STR_INIT; git_oid oid; bool append_hash = false; + int error; if (size == 0) return 0; @@ -82,7 +83,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) abort(); } - if (git_indexer_new(&indexer, ".", 0, odb, NULL) < 0) { +#ifdef GIT_EXPERIMENTAL_SHA256 + error = git_indexer_new(&indexer, ".", GIT_OID_SHA1, NULL); +#else + error = git_indexer_new(&indexer, ".", 0, odb, NULL); +#endif + + if (error < 0) { fprintf(stderr, "Failed to create the indexer: %s\n", git_error_last()->message); abort(); diff --git a/include/git2/indexer.h b/include/git2/indexer.h index ffe9bf366..630eef934 100644 --- a/include/git2/indexer.h +++ b/include/git2/indexer.h @@ -62,6 +62,19 @@ typedef int GIT_CALLBACK(git_indexer_progress_cb)(const git_indexer_progress *st typedef struct git_indexer_options { unsigned int version; +#ifdef GIT_EXPERIMENTAL_SHA256 + /** permissions to use creating packfile or 0 for defaults */ + unsigned int mode; + + /** + * object database from which to read base objects when + * fixing thin packs. This can be NULL if there are no thin + * packs; if a thin pack is encountered, an error will be + * returned if there are bases missing. + */ + git_odb *odb; +#endif + /** progress_cb function to call with progress information */ git_indexer_progress_cb progress_cb; @@ -87,6 +100,21 @@ GIT_EXTERN(int) git_indexer_options_init( git_indexer_options *opts, unsigned int version); +#ifdef GIT_EXPERIMENTAL_SHA256 +/** + * Create a new indexer instance + * + * @param out where to store the indexer instance + * @param path to the directory where the packfile should be stored + * @param oid_type the oid type to use for objects + * @return 0 or an error code. + */ +GIT_EXTERN(int) git_indexer_new( + git_indexer **out, + const char *path, + git_oid_t oid_type, + git_indexer_options *opts); +#else /** * Create a new indexer instance * @@ -106,6 +134,7 @@ GIT_EXTERN(int) git_indexer_new( unsigned int mode, git_odb *odb, git_indexer_options *opts); +#endif /** * Add data to the indexer diff --git a/include/git2/object.h b/include/git2/object.h index 5610a476f..6384aaa6e 100644 --- a/include/git2/object.h +++ b/include/git2/object.h @@ -225,6 +225,7 @@ GIT_EXTERN(int) git_object_peel( */ GIT_EXTERN(int) git_object_dup(git_object **dest, git_object *source); +#ifdef GIT_EXPERIMENTAL_SHA256 /** * Analyzes a buffer of raw object content and determines its validity. * Tree, commit, and tag objects will be parsed and ensured that they @@ -238,14 +239,39 @@ GIT_EXTERN(int) git_object_dup(git_object **dest, git_object *source); * @param valid Output pointer to set with validity of the object content * @param buf The contents to validate * @param len The length of the buffer - * @param type The type of the object in the buffer + * @param object_type The type of the object in the buffer + * @param oid_type The object ID type for the OIDs in the given buffer * @return 0 on success or an error code */ GIT_EXTERN(int) git_object_rawcontent_is_valid( int *valid, const char *buf, size_t len, - git_object_t type); + git_object_t object_type, + git_oid_t oid_type); +#else +/** + * Analyzes a buffer of raw object content and determines its validity. + * Tree, commit, and tag objects will be parsed and ensured that they + * are valid, parseable content. (Blobs are always valid by definition.) + * An error message will be set with an informative message if the object + * is not valid. + * + * @warning This function is experimental and its signature may change in + * the future. + * + * @param valid Output pointer to set with validity of the object content + * @param buf The contents to validate + * @param len The length of the buffer + * @param object_type The type of the object in the buffer + * @return 0 on success or an error code + */ +GIT_EXTERN(int) git_object_rawcontent_is_valid( + int *valid, + const char *buf, + size_t len, + git_object_t object_type); +#endif /** @} */ GIT_END_DECL diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c index a64db8823..93b980d66 100644 --- a/src/cli/cmd_hash_object.c +++ b/src/cli/cmd_hash_object.c @@ -49,26 +49,37 @@ static void print_help(void) cli_opt_help_fprint(stdout, opts); } -static int hash_buf(git_odb *odb, git_str *buf, git_object_t type) +static int hash_buf( + git_odb *odb, + git_str *buf, + git_object_t object_type, + git_oid_t oid_type) { git_oid oid; if (!literally) { int valid = 0; - if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, type) < 0 || !valid) +#ifdef GIT_EXPERIMENTAL_SHA256 + if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type, oid_type) < 0 || !valid) return cli_error_git(); +#else + GIT_UNUSED(oid_type); + + if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type) < 0 || !valid) + return cli_error_git(); +#endif } if (write_object) { - if (git_odb_write(&oid, odb, buf->ptr, buf->size, type) < 0) + if (git_odb_write(&oid, odb, buf->ptr, buf->size, object_type) < 0) return cli_error_git(); } else { #ifdef GIT_EXPERIMENTAL_SHA256 - if (git_odb_hash(&oid, buf->ptr, buf->size, type, GIT_OID_SHA1) < 0) + if (git_odb_hash(&oid, buf->ptr, buf->size, object_type, GIT_OID_SHA1) < 0) return cli_error_git(); #else - if (git_odb_hash(&oid, buf->ptr, buf->size, type) < 0) + if (git_odb_hash(&oid, buf->ptr, buf->size, object_type) < 0) return cli_error_git(); #endif } @@ -83,9 +94,10 @@ int cmd_hash_object(int argc, char **argv) { git_repository *repo = NULL; git_odb *odb = NULL; + git_oid_t oid_type; git_str buf = GIT_STR_INIT; cli_opt invalid_opt; - git_object_t type = GIT_OBJECT_BLOB; + git_object_t object_type = GIT_OBJECT_BLOB; char **filename; int ret = 0; @@ -97,7 +109,7 @@ int cmd_hash_object(int argc, char **argv) return 0; } - if (type_name && (type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID) + if (type_name && (object_type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID) return cli_error_usage("invalid object type '%s'", type_name); if (write_object && @@ -107,6 +119,8 @@ int cmd_hash_object(int argc, char **argv) goto done; } + oid_type = git_repository_oid_type(repo); + /* * TODO: we're reading blobs, we shouldn't pull them all into main * memory, we should just stream them into the odb instead. @@ -118,7 +132,7 @@ int cmd_hash_object(int argc, char **argv) goto done; } - if ((ret = hash_buf(odb, &buf, type)) != 0) + if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0) goto done; } else { for (filename = filenames; *filename; filename++) { @@ -127,7 +141,7 @@ int cmd_hash_object(int argc, char **argv) goto done; } - if ((ret = hash_buf(odb, &buf, type)) != 0) + if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0) goto done; } } diff --git a/src/libgit2/blob.c b/src/libgit2/blob.c index b1680d3a8..5cfd7474b 100644 --- a/src/libgit2/blob.c +++ b/src/libgit2/blob.c @@ -52,11 +52,12 @@ void git_blob__free(void *_blob) git__free(blob); } -int git_blob__parse_raw(void *_blob, const char *data, size_t size) +int git_blob__parse_raw(void *_blob, const char *data, size_t size, git_oid_t oid_type) { git_blob *blob = (git_blob *) _blob; GIT_ASSERT_ARG(blob); + GIT_UNUSED(oid_type); blob->raw = 1; blob->data.raw.data = data; @@ -64,11 +65,12 @@ int git_blob__parse_raw(void *_blob, const char *data, size_t size) return 0; } -int git_blob__parse(void *_blob, git_odb_object *odb_obj) +int git_blob__parse(void *_blob, git_odb_object *odb_obj, git_oid_t oid_type) { git_blob *blob = (git_blob *) _blob; GIT_ASSERT_ARG(blob); + GIT_UNUSED(oid_type); git_cached_obj_incref((git_cached_obj *)odb_obj); blob->raw = 0; diff --git a/src/libgit2/blob.h b/src/libgit2/blob.h index 9a5dda225..d6c9dd99b 100644 --- a/src/libgit2/blob.h +++ b/src/libgit2/blob.h @@ -36,8 +36,8 @@ struct git_blob { } while(0) void git_blob__free(void *blob); -int git_blob__parse(void *blob, git_odb_object *obj); -int git_blob__parse_raw(void *blob, const char *data, size_t size); +int git_blob__parse(void *blob, git_odb_object *obj, git_oid_t oid_type); +int git_blob__parse_raw(void *blob, const char *data, size_t size, git_oid_t oid_type); int git_blob__getbuf(git_str *buffer, git_blob *blob); extern int git_blob__create_from_paths( diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c index 114ae6fc9..d85fefb3d 100644 --- a/src/libgit2/commit.c +++ b/src/libgit2/commit.c @@ -390,7 +390,11 @@ int git_commit_amend( return error; } -static int commit_parse(git_commit *commit, const char *data, size_t size, unsigned int flags) +static int commit_parse( + git_commit *commit, + const char *data, + size_t size, + git_commit__parse_options *opts) { const char *buffer_start = data, *buffer; const char *buffer_end = buffer_start + size; @@ -401,6 +405,7 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig GIT_ASSERT_ARG(commit); GIT_ASSERT_ARG(data); + GIT_ASSERT_ARG(opts); buffer = buffer_start; @@ -409,13 +414,14 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig GIT_ERROR_CHECK_ARRAY(commit->parent_ids); /* The tree is always the first field */ - if (!(flags & GIT_COMMIT_PARSE_QUICK)) { + if (!(opts->flags & GIT_COMMIT_PARSE_QUICK)) { if (git_object__parse_oid_header(&commit->tree_id, &buffer, buffer_end, "tree ", - GIT_OID_SHA1) < 0) + opts->oid_type) < 0) goto bad_buffer; } else { - size_t tree_len = strlen("tree ") + GIT_OID_SHA1_HEXSIZE + 1; + size_t tree_len = strlen("tree ") + git_oid_hexsize(opts->oid_type) + 1; + if (buffer + tree_len > buffer_end) goto bad_buffer; buffer += tree_len; @@ -427,14 +433,14 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig while (git_object__parse_oid_header(&parent_id, &buffer, buffer_end, "parent ", - GIT_OID_SHA1) == 0) { + opts->oid_type) == 0) { git_oid *new_id = git_array_alloc(commit->parent_ids); GIT_ERROR_CHECK_ALLOC(new_id); git_oid_cpy(new_id, &parent_id); } - if (!(flags & GIT_COMMIT_PARSE_QUICK)) { + if (!opts || !(opts->flags & GIT_COMMIT_PARSE_QUICK)) { commit->author = git__malloc(sizeof(git_signature)); GIT_ERROR_CHECK_ALLOC(commit->author); @@ -458,7 +464,7 @@ static int commit_parse(git_commit *commit, const char *data, size_t size, unsig if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n')) < 0) return error; - if (flags & GIT_COMMIT_PARSE_QUICK) + if (opts && opts->flags & GIT_COMMIT_PARSE_QUICK) return 0; /* Parse add'l header entries */ @@ -503,19 +509,39 @@ bad_buffer: return GIT_EINVALID; } -int git_commit__parse_raw(void *commit, const char *data, size_t size) +int git_commit__parse( + void *commit, + git_odb_object *odb_obj, + git_oid_t oid_type) { - return commit_parse(commit, data, size, 0); + git_commit__parse_options parse_options = {0}; + parse_options.oid_type = oid_type; + + return git_commit__parse_ext(commit, odb_obj, &parse_options); } -int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags) +int git_commit__parse_raw( + void *commit, + const char *data, + size_t size, + git_oid_t oid_type) { - return commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags); + git_commit__parse_options parse_options = {0}; + parse_options.oid_type = oid_type; + + return commit_parse(commit, data, size, &parse_options); } -int git_commit__parse(void *_commit, git_odb_object *odb_obj) +int git_commit__parse_ext( + git_commit *commit, + git_odb_object *odb_obj, + git_commit__parse_options *parse_opts) { - return git_commit__parse_ext(_commit, odb_obj, 0); + return commit_parse( + commit, + git_odb_object_data(odb_obj), + git_odb_object_size(odb_obj), + parse_opts); } #define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \ @@ -985,11 +1011,14 @@ int git_commit_create_with_signature( git_str commit = GIT_STR_INIT; git_commit *parsed; git_array_oid_t parents = GIT_ARRAY_INIT; + git_commit__parse_options parse_opts = {0}; + + parse_opts.oid_type = repo->oid_type; /* The first step is to verify that all the tree and parents exist */ parsed = git__calloc(1, sizeof(git_commit)); GIT_ERROR_CHECK_ALLOC(parsed); - if (commit_parse(parsed, commit_content, strlen(commit_content), 0) < 0) { + if (commit_parse(parsed, commit_content, strlen(commit_content), &parse_opts) < 0) { error = -1; goto cleanup; } diff --git a/src/libgit2/commit.h b/src/libgit2/commit.h index 7a2454e61..c25fee327 100644 --- a/src/libgit2/commit.h +++ b/src/libgit2/commit.h @@ -33,6 +33,16 @@ struct git_commit { char *body; }; +typedef struct { + git_oid_t oid_type; + unsigned int flags; +} git_commit__parse_options; + +typedef enum { + /** Only parse parents and committer info */ + GIT_COMMIT_PARSE_QUICK = (1 << 0) +} git_commit__parse_flags; + int git_commit__header_field( git_str *out, const git_commit *commit, @@ -56,14 +66,22 @@ int git_commit__create_buffer( size_t parent_count, const git_commit *parents[]); +int git_commit__parse( + void *commit, + git_odb_object *obj, + git_oid_t oid_type); + +int git_commit__parse_raw( + void *commit, + const char *data, + size_t size, + git_oid_t oid_type); + +int git_commit__parse_ext( + git_commit *commit, + git_odb_object *odb_obj, + git_commit__parse_options *parse_opts); + void git_commit__free(void *commit); -int git_commit__parse(void *commit, git_odb_object *obj); -int git_commit__parse_raw(void *commit, const char *data, size_t size); - -typedef enum { - GIT_COMMIT_PARSE_QUICK = (1 << 0) /**< Only parse parents and committer info */ -} git_commit__parse_flags; - -int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags); #endif diff --git a/src/libgit2/commit_list.c b/src/libgit2/commit_list.c index 511d7291f..12b329b25 100644 --- a/src/libgit2/commit_list.c +++ b/src/libgit2/commit_list.c @@ -124,13 +124,17 @@ static int commit_quick_parse( { git_oid *parent_oid; git_commit *commit; + git_commit__parse_options parse_opts = { + GIT_OID_SHA1, + GIT_COMMIT_PARSE_QUICK + }; size_t i; commit = git__calloc(1, sizeof(*commit)); GIT_ERROR_CHECK_ALLOC(commit); commit->object.repo = walk->repo; - if (git_commit__parse_ext(commit, obj, GIT_COMMIT_PARSE_QUICK) < 0) { + if (git_commit__parse_ext(commit, obj, &parse_opts) < 0) { git__free(commit); return -1; } diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index 98408646a..dfc326e02 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -42,6 +42,7 @@ struct git_indexer { have_delta :1, do_fsync :1, do_verify :1; + git_oid_t oid_type; struct git_pack_header hdr; struct git_pack_file *pack; unsigned int mode; @@ -68,7 +69,7 @@ struct git_indexer { git_odb *odb; /* Fields for calculating the packfile trailer (hash of everything before it) */ - char inbuf[GIT_OID_SHA1_SIZE]; + char inbuf[GIT_OID_MAX_SIZE]; size_t inbuf_len; git_hash_ctx trailer; }; @@ -136,12 +137,13 @@ int git_indexer_init_options(git_indexer_options *opts, unsigned int version) } #endif -int git_indexer_new( - git_indexer **out, - const char *prefix, - unsigned int mode, - git_odb *odb, - git_indexer_options *in_opts) +static int indexer_new( + git_indexer **out, + const char *prefix, + git_oid_t oid_type, + unsigned int mode, + git_odb *odb, + git_indexer_options *in_opts) { git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; git_indexer *idx; @@ -154,6 +156,7 @@ int git_indexer_new( idx = git__calloc(1, sizeof(git_indexer)); GIT_ERROR_CHECK_ALLOC(idx); + idx->oid_type = oid_type; idx->odb = odb; idx->progress_cb = opts.progress_cb; idx->progress_payload = opts.progress_cb_payload; @@ -209,6 +212,33 @@ cleanup: return -1; } +#ifdef GIT_EXPERIMENTAL_SHA256 +int git_indexer_new( + git_indexer **out, + const char *prefix, + git_oid_t oid_type, + git_indexer_options *opts) +{ + return indexer_new( + out, + prefix, + oid_type, + opts ? opts->mode : 0, + opts ? opts->odb : NULL, + opts); +} +#else +int git_indexer_new( + git_indexer **out, + const char *prefix, + unsigned int mode, + git_odb *odb, + git_indexer_options *opts) +{ + return indexer_new(out, prefix, GIT_OID_SHA1, mode, odb, opts); +} +#endif + void git_indexer__set_fsync(git_indexer *idx, int do_fsync) { idx->do_fsync = !!do_fsync; @@ -273,7 +303,7 @@ static int advance_delta_offset(git_indexer *idx, git_object_t type) GIT_ASSERT_ARG(type == GIT_OBJECT_REF_DELTA || type == GIT_OBJECT_OFS_DELTA); if (type == GIT_OBJECT_REF_DELTA) { - idx->off += GIT_OID_SHA1_SIZE; + idx->off += git_oid_size(idx->oid_type); } else { off64_t base_off; int error = get_delta_base(&base_off, idx->pack, &w, &idx->off, type, idx->entry_start); @@ -357,7 +387,7 @@ static int check_object_connectivity(git_indexer *idx, const git_rawobj *obj) obj->type != GIT_OBJECT_TAG) return 0; - if (git_object__from_raw(&object, obj->data, obj->len, obj->type) < 0) { + if (git_object__from_raw(&object, obj->data, obj->len, obj->type, idx->oid_type) < 0) { /* * parse_raw returns EINVALID on invalid data; downgrade * that to a normal -1 error code. @@ -447,7 +477,7 @@ static int store_object(git_indexer *idx) } #ifdef GIT_EXPERIMENTAL_SHA256 - oid.type = GIT_OID_SHA1; + oid.type = idx->oid_type; #endif entry_size = idx->off - entry_start; @@ -550,7 +580,7 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, off64_t entry_start) entry = git__calloc(1, sizeof(*entry)); GIT_ERROR_CHECK_ALLOC(entry); - if (git_odb__hashobj(&oid, obj, GIT_OID_SHA1) < 0) { + if (git_odb__hashobj(&oid, obj, idx->oid_type) < 0) { git_error_set(GIT_ERROR_INDEXER, "failed to hash object"); goto on_error; } @@ -588,30 +618,31 @@ static int do_progress_callback(git_indexer *idx, git_indexer_progress *stats) static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) { size_t to_expell, to_keep; + size_t oid_size = git_oid_size(idx->oid_type); if (size == 0) return; /* Easy case, dump the buffer and the data minus the last 20 bytes */ - if (size >= GIT_OID_SHA1_SIZE) { + if (size >= oid_size) { git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len); - git_hash_update(&idx->trailer, data, size - GIT_OID_SHA1_SIZE); + git_hash_update(&idx->trailer, data, size - oid_size); - data += size - GIT_OID_SHA1_SIZE; - memcpy(idx->inbuf, data, GIT_OID_SHA1_SIZE); - idx->inbuf_len = GIT_OID_SHA1_SIZE; + data += size - oid_size; + memcpy(idx->inbuf, data, oid_size); + idx->inbuf_len = oid_size; return; } /* We can just append */ - if (idx->inbuf_len + size <= GIT_OID_SHA1_SIZE) { + if (idx->inbuf_len + size <= oid_size) { memcpy(idx->inbuf + idx->inbuf_len, data, size); idx->inbuf_len += size; return; } /* We need to partially drain the buffer and then append */ - to_keep = GIT_OID_SHA1_SIZE - size; + to_keep = oid_size - size; to_expell = idx->inbuf_len - to_keep; git_hash_update(&idx->trailer, idx->inbuf, to_expell); @@ -906,7 +937,7 @@ static int index_path(git_str *path, git_indexer *idx, const char *suffix) slash--; if (git_str_grow(path, slash + 1 + strlen(prefix) + - GIT_OID_SHA1_HEXSIZE + strlen(suffix) + 1) < 0) + git_oid_hexsize(idx->oid_type) + strlen(suffix) + 1) < 0) return -1; git_str_truncate(path, slash); @@ -923,7 +954,7 @@ static int index_path(git_str *path, git_indexer *idx, const char *suffix) */ static int seek_back_trailer(git_indexer *idx) { - idx->pack->mwf.size -= GIT_OID_SHA1_SIZE; + idx->pack->mwf.size -= git_oid_size(idx->oid_type); return git_mwindow_free_all(&idx->pack->mwf); } @@ -983,7 +1014,7 @@ static int inject_object(git_indexer *idx, git_oid *id) if ((error = append_to_pack(idx, empty_checksum, checksum_size)) < 0) goto cleanup; - idx->pack->mwf.size += GIT_OID_SHA1_SIZE; + idx->pack->mwf.size += git_oid_size(idx->oid_type); pentry = git__calloc(1, sizeof(struct git_pack_entry)); GIT_ERROR_CHECK_ALLOC(pentry); @@ -1046,13 +1077,13 @@ static int fix_thin_pack(git_indexer *idx, git_indexer_progress *stats) } /* curpos now points to the base information, which is an OID */ - base_info = git_mwindow_open(&idx->pack->mwf, &w, curpos, GIT_OID_SHA1_SIZE, &left); + base_info = git_mwindow_open(&idx->pack->mwf, &w, curpos, git_oid_size(idx->oid_type), &left); if (base_info == NULL) { git_error_set(GIT_ERROR_INDEXER, "failed to map delta information"); return -1; } - git_oid__fromraw(&base, base_info, GIT_OID_SHA1); + git_oid__fromraw(&base, base_info, idx->oid_type); git_mwindow_close(&w); if (has_entry(idx, &base)) @@ -1275,7 +1306,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) /* Write out the object names (SHA-1 hashes) */ git_vector_foreach(&idx->objects, i, entry) { - git_filebuf_write(&index_file, &entry->oid.id, GIT_OID_SHA1_SIZE); + git_filebuf_write(&index_file, &entry->oid.id, git_oid_size(idx->oid_type)); } /* Write out the CRC32 values */ diff --git a/src/libgit2/object.c b/src/libgit2/object.c index d45465678..d87d40cf1 100644 --- a/src/libgit2/object.c +++ b/src/libgit2/object.c @@ -27,8 +27,8 @@ typedef struct { const char *str; /* type name string */ size_t size; /* size in bytes of the object structure */ - int (*parse)(void *self, git_odb_object *obj); - int (*parse_raw)(void *self, const char *data, size_t size); + int (*parse)(void *self, git_odb_object *obj, git_oid_t oid_type); + int (*parse_raw)(void *self, const char *data, size_t size, git_oid_t oid_type); void (*free)(void *self); } git_object_def; @@ -60,7 +60,8 @@ int git_object__from_raw( git_object **object_out, const char *data, size_t size, - git_object_t type) + git_object_t object_type, + git_oid_t oid_type) { git_object_def *def; git_object *object; @@ -71,12 +72,15 @@ int git_object__from_raw( *object_out = NULL; /* Validate type match */ - if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) { + if (object_type != GIT_OBJECT_BLOB && + object_type != GIT_OBJECT_TREE && + object_type != GIT_OBJECT_COMMIT && + object_type != GIT_OBJECT_TAG) { git_error_set(GIT_ERROR_INVALID, "the requested type is invalid"); return GIT_ENOTFOUND; } - if ((object_size = git_object__size(type)) == 0) { + if ((object_size = git_object__size(object_type)) == 0) { git_error_set(GIT_ERROR_INVALID, "the requested type is invalid"); return GIT_ENOTFOUND; } @@ -85,15 +89,15 @@ int git_object__from_raw( object = git__calloc(1, object_size); GIT_ERROR_CHECK_ALLOC(object); object->cached.flags = GIT_CACHE_STORE_PARSED; - object->cached.type = type; - if ((error = git_odb__hash(&object->cached.oid, data, size, type, GIT_OID_SHA1)) < 0) + object->cached.type = object_type; + if ((error = git_odb__hash(&object->cached.oid, data, size, object_type, oid_type)) < 0) return error; /* Parse raw object data */ - def = &git_objects_table[type]; + def = &git_objects_table[object_type]; GIT_ASSERT(def->free && def->parse_raw); - if ((error = def->parse_raw(object, data, size)) < 0) { + if ((error = def->parse_raw(object, data, size, oid_type)) < 0) { def->free(object); return error; } @@ -143,7 +147,7 @@ int git_object__from_odb_object( def = &git_objects_table[odb_obj->cached.type]; GIT_ASSERT(def->free && def->parse); - if ((error = def->parse(object, odb_obj)) < 0) { + if ((error = def->parse(object, odb_obj, repo->oid_type)) < 0) { /* * parse returns EINVALID on invalid data; downgrade * that to a normal -1 error code. @@ -357,12 +361,11 @@ static int dereference_object(git_object **dereferenced, git_object *obj) static int peel_error(int error, const git_oid *oid, git_object_t type) { const char *type_name; - char hex_oid[GIT_OID_SHA1_HEXSIZE + 1]; + char hex_oid[GIT_OID_MAX_HEXSIZE + 1]; type_name = git_object_type2string(type); - git_oid_fmt(hex_oid, oid); - hex_oid[GIT_OID_SHA1_HEXSIZE] = '\0'; + git_oid_nfmt(hex_oid, GIT_OID_MAX_HEXSIZE + 1, oid); git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be " "successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type); @@ -576,21 +579,29 @@ int git_object_rawcontent_is_valid( int *valid, const char *buf, size_t len, - git_object_t type) + git_object_t object_type +#ifdef GIT_EXPERIMENTAL_SHA256 + , git_oid_t oid_type +#endif + ) { git_object *obj = NULL; int error; +#ifndef GIT_EXPERIMENTAL_SHA256 + git_oid_t oid_type = GIT_OID_SHA1; +#endif + GIT_ASSERT_ARG(valid); GIT_ASSERT_ARG(buf); /* Blobs are always valid; don't bother parsing. */ - if (type == GIT_OBJECT_BLOB) { + if (object_type == GIT_OBJECT_BLOB) { *valid = 1; return 0; } - error = git_object__from_raw(&obj, buf, len, type); + error = git_object__from_raw(&obj, buf, len, object_type, oid_type); git_object_free(obj); if (error == 0) { @@ -611,7 +622,7 @@ int git_object__parse_oid_header( const char *header, git_oid_t oid_type) { - const size_t sha_len = GIT_OID_SHA1_HEXSIZE; + const size_t sha_len = git_oid_hexsize(oid_type); const size_t header_len = strlen(header); const char *buffer = *buffer_out; diff --git a/src/libgit2/object.h b/src/libgit2/object.h index 980e8627e..a29fdfbf3 100644 --- a/src/libgit2/object.h +++ b/src/libgit2/object.h @@ -33,7 +33,8 @@ int git_object__from_raw( git_object **object_out, const char *data, size_t size, - git_object_t type); + git_object_t object_type, + git_oid_t oid_type); int git_object__from_odb_object( git_object **object_out, diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c index 814c0bc75..1b1d122b0 100644 --- a/src/libgit2/odb_pack.c +++ b/src/libgit2/odb_pack.c @@ -718,6 +718,7 @@ static int pack_backend__writepack(struct git_odb_writepack **out, git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; struct pack_backend *backend; struct pack_writepack *writepack; + int error; GIT_ASSERT_ARG(out); GIT_ASSERT_ARG(_backend); @@ -732,11 +733,20 @@ static int pack_backend__writepack(struct git_odb_writepack **out, writepack = git__calloc(1, sizeof(struct pack_writepack)); GIT_ERROR_CHECK_ALLOC(writepack); - if (git_indexer_new(&writepack->indexer, - backend->pack_folder, 0, odb, &opts) < 0) { - git__free(writepack); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + + error = git_indexer_new(&writepack->indexer, + backend->pack_folder, + backend->opts.oid_type, + &opts); +#else + error = git_indexer_new(&writepack->indexer, + backend->pack_folder, 0, odb, &opts); +#endif + + if (error < 0) return -1; - } writepack->parent.backend = _backend; writepack->parent.append = pack_backend__writepack_append; diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c index 068231649..20a5dfcbd 100644 --- a/src/libgit2/pack-objects.c +++ b/src/libgit2/pack-objects.c @@ -1407,7 +1407,18 @@ int git_packbuilder_write( opts.progress_cb = progress_cb; opts.progress_cb_payload = progress_cb_payload; - if ((error = git_indexer_new(&indexer, path, mode, pb->odb, &opts)) < 0) + /* TODO: SHA256 */ + +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.mode = mode; + opts.odb = pb->odb; + + error = git_indexer_new(&indexer, path, GIT_OID_SHA1, &opts); +#else + error = git_indexer_new(&indexer, path, mode, pb->odb, &opts); +#endif + + if (error < 0) goto cleanup; if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 043cfd1fd..2da6caf3a 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1278,11 +1278,14 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo) *out = git_atomic_load(repo->_odb); if (*out == NULL) { git_str odb_path = GIT_STR_INIT; + git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT; git_odb *odb; + odb_opts.oid_type = repo->oid_type; + if ((error = git_repository__item_path(&odb_path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0 || - (error = git_odb__new(&odb, NULL)) < 0) + (error = git_odb__new(&odb, &odb_opts)) < 0) return error; GIT_REFCOUNT_OWN(odb, repo); diff --git a/src/libgit2/tag.c b/src/libgit2/tag.c index 0a90e393c..562ec13ea 100644 --- a/src/libgit2/tag.c +++ b/src/libgit2/tag.c @@ -65,7 +65,11 @@ static int tag_error(const char *str) return GIT_EINVALID; } -static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) +static int tag_parse( + git_tag *tag, + const char *buffer, + const char *buffer_end, + git_oid_t oid_type) { static const char *tag_types[] = { NULL, "commit\n", "tree\n", "blob\n", "tag\n" @@ -76,7 +80,7 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) int error; if (git_object__parse_oid_header(&tag->target, - &buffer, buffer_end, "object ", GIT_OID_SHA1) < 0) + &buffer, buffer_end, "object ", oid_type) < 0) return tag_error("object field invalid"); if (buffer + 5 >= buffer_end) @@ -161,18 +165,25 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end) return 0; } -int git_tag__parse_raw(void *_tag, const char *data, size_t size) +int git_tag__parse_raw( + void *_tag, + const char *data, + size_t size, + git_oid_t oid_type) { - return tag_parse(_tag, data, data + size); + return tag_parse(_tag, data, data + size, oid_type); } -int git_tag__parse(void *_tag, git_odb_object *odb_obj) +int git_tag__parse( + void *_tag, + git_odb_object *odb_obj, + git_oid_t oid_type) { git_tag *tag = _tag; const char *buffer = git_odb_object_data(odb_obj); const char *buffer_end = buffer + git_odb_object_size(odb_obj); - return tag_parse(tag, buffer, buffer_end); + return tag_parse(tag, buffer, buffer_end, oid_type); } static int retrieve_tag_reference( @@ -374,7 +385,7 @@ int git_tag_create_from_buffer(git_oid *oid, git_repository *repo, const char *b return -1; /* validate the buffer */ - if (tag_parse(&tag, buffer, buffer + strlen(buffer)) < 0) + if (tag_parse(&tag, buffer, buffer + strlen(buffer), repo->oid_type) < 0) return -1; /* validate the target */ diff --git a/src/libgit2/tag.h b/src/libgit2/tag.h index 76ae1508e..fdaaa463c 100644 --- a/src/libgit2/tag.h +++ b/src/libgit2/tag.h @@ -25,7 +25,7 @@ struct git_tag { }; void git_tag__free(void *tag); -int git_tag__parse(void *tag, git_odb_object *obj); -int git_tag__parse_raw(void *tag, const char *data, size_t size); +int git_tag__parse(void *tag, git_odb_object *obj, git_oid_t oid_type); +int git_tag__parse_raw(void *tag, const char *data, size_t size, git_oid_t oid_type); #endif diff --git a/src/libgit2/tree.c b/src/libgit2/tree.c index 9a43d585c..9293d9422 100644 --- a/src/libgit2/tree.c +++ b/src/libgit2/tree.c @@ -85,11 +85,17 @@ static git_tree_entry *alloc_entry(const char *filename, size_t filename_len, co char *filename_ptr; size_t tree_len; +#ifdef GIT_EXPERIMENTAL_SHA256 + size_t oid_size = git_oid_size(id->type); +#else + size_t oid_size = GIT_OID_SHA1_SIZE; +#endif + TREE_ENTRY_CHECK_NAMELEN(filename_len); if (GIT_ADD_SIZET_OVERFLOW(&tree_len, sizeof(git_tree_entry), filename_len) || GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, 1) || - GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, GIT_OID_SHA1_SIZE)) + GIT_ADD_SIZET_OVERFLOW(&tree_len, tree_len, oid_size)) return NULL; entry = git__calloc(1, tree_len); @@ -383,11 +389,12 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len, return 0; } -int git_tree__parse_raw(void *_tree, const char *data, size_t size) +int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type) { git_tree *tree = _tree; const char *buffer; const char *buffer_end; + const long oid_size = (long)git_oid_size(oid_type); buffer = data; buffer_end = buffer + size; @@ -414,35 +421,33 @@ int git_tree__parse_raw(void *_tree, const char *data, size_t size) if ((filename_len = nul - buffer) == 0 || filename_len > UINT16_MAX) return tree_parse_error("failed to parse tree: can't parse filename", NULL); - if ((buffer_end - (nul + 1)) < GIT_OID_SHA1_SIZE) + if ((buffer_end - (nul + 1)) < (long)oid_size) return tree_parse_error("failed to parse tree: can't parse OID", NULL); /* Allocate the entry */ - { - entry = git_array_alloc(tree->entries); - GIT_ERROR_CHECK_ALLOC(entry); - - entry->attr = attr; - entry->filename_len = (uint16_t)filename_len; - entry->filename = buffer; - git_oid__fromraw(&entry->oid, ((unsigned char *) buffer + filename_len + 1), GIT_OID_SHA1); - } + entry = git_array_alloc(tree->entries); + GIT_ERROR_CHECK_ALLOC(entry); + entry->attr = attr; + entry->filename_len = (uint16_t)filename_len; + entry->filename = buffer; buffer += filename_len + 1; - buffer += GIT_OID_SHA1_SIZE; + + git_oid__fromraw(&entry->oid, (unsigned char *)buffer, oid_type); + buffer += oid_size; } return 0; } -int git_tree__parse(void *_tree, git_odb_object *odb_obj) +int git_tree__parse(void *_tree, git_odb_object *odb_obj, git_oid_t oid_type) { git_tree *tree = _tree; const char *data = git_odb_object_data(odb_obj); size_t size = git_odb_object_size(odb_obj); int error; - if ((error = git_tree__parse_raw(tree, data, size)) < 0 || + if ((error = git_tree__parse_raw(tree, data, size, oid_type)) < 0 || (error = git_odb_object_dup(&tree->odb_obj, odb_obj)) < 0) return error; @@ -506,6 +511,7 @@ static int git_treebuilder__write_with_buffer( git_odb *odb; git_tree_entry *entry; git_vector entries = GIT_VECTOR_INIT; + size_t oid_size = git_oid_size(bld->repo->oid_type); git_str_clear(buf); @@ -529,7 +535,7 @@ static int git_treebuilder__write_with_buffer( git_str_printf(buf, "%o ", entry->attr); git_str_put(buf, entry->filename, entry->filename_len + 1); - git_str_put(buf, (char *)entry->oid.id, GIT_OID_SHA1_SIZE); + git_str_put(buf, (char *)entry->oid.id, oid_size); if (git_str_oom(buf)) { error = -1; diff --git a/src/libgit2/tree.h b/src/libgit2/tree.h index 0dd963ff2..5088450ab 100644 --- a/src/libgit2/tree.h +++ b/src/libgit2/tree.h @@ -41,8 +41,8 @@ GIT_INLINE(bool) git_tree_entry__is_tree(const struct git_tree_entry *e) } void git_tree__free(void *tree); -int git_tree__parse(void *tree, git_odb_object *obj); -int git_tree__parse_raw(void *_tree, const char *data, size_t size); +int git_tree__parse(void *tree, git_odb_object *obj, git_oid_t oid_type); +int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oid_type); /** * Write a tree to the given repository diff --git a/tests/libgit2/commit/parse.c b/tests/libgit2/commit/parse.c index b313fc308..3a1fc3d26 100644 --- a/tests/libgit2/commit/parse.c +++ b/tests/libgit2/commit/parse.c @@ -287,7 +287,7 @@ static int parse_commit(git_commit **out, const char *buffer) fake_odb_object.buffer = (char *)buffer; fake_odb_object.cached.size = strlen(fake_odb_object.buffer); - error = git_commit__parse(commit, &fake_odb_object); + error = git_commit__parse(commit, &fake_odb_object, GIT_OID_SHA1); *out = commit; return error; diff --git a/tests/libgit2/object/commit/parse.c b/tests/libgit2/object/commit/parse.c index 28a3ccd85..6f9a65507 100644 --- a/tests/libgit2/object/commit/parse.c +++ b/tests/libgit2/object/commit/parse.c @@ -3,7 +3,10 @@ #include "object.h" #include "signature.h" -static void assert_commit_parses(const char *data, size_t datalen, +static void assert_commit_parses( + const char *data, + size_t datalen, + git_oid_t oid_type, const char *expected_treeid, const char *expected_author, const char *expected_committer, @@ -14,7 +17,7 @@ static void assert_commit_parses(const char *data, size_t datalen, git_commit *commit; if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &commit, data, datalen, GIT_OBJECT_COMMIT)); + cl_git_pass(git_object__from_raw((git_object **) &commit, data, datalen, GIT_OBJECT_COMMIT, oid_type)); if (expected_author) { git_signature *author; @@ -51,7 +54,7 @@ static void assert_commit_parses(const char *data, size_t datalen, if (expected_treeid) { git_oid tree_oid; - cl_git_pass(git_oid__fromstr(&tree_oid, expected_treeid, GIT_OID_SHA1)); + cl_git_pass(git_oid__fromstr(&tree_oid, expected_treeid, oid_type)); cl_assert_equal_oid(&tree_oid, &commit->tree_id); } @@ -60,15 +63,18 @@ static void assert_commit_parses(const char *data, size_t datalen, git_object__free(&commit->object); } -static void assert_commit_fails(const char *data, size_t datalen) +static void assert_commit_fails( + const char *data, + size_t datalen, + git_oid_t oid_type) { git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_COMMIT)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_COMMIT, oid_type)); } -void test_object_commit_parse__parsing_commit_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -77,7 +83,7 @@ void test_object_commit_parse__parsing_commit_succeeds(void) "encoding Encoding\n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -85,7 +91,7 @@ void test_object_commit_parse__parsing_commit_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_without_encoding_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -93,7 +99,7 @@ void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) "committer Committer \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -101,7 +107,7 @@ void test_object_commit_parse__parsing_commit_without_encoding_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_multiple_authors_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -112,7 +118,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(voi "committer Committer \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author1 ", "Committer ", @@ -120,7 +126,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_authors_succeeds(voi "Message", 0); } -void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_multiple_committers_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -131,7 +137,7 @@ void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds( "committer Committer4 \n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer1 ", @@ -139,13 +145,13 @@ void test_object_commit_parse__parsing_commit_with_multiple_committers_succeeds( "Message", 0); } -void test_object_commit_parse__parsing_commit_without_message_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_without_message_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "author Author \n" "committer Committer \n"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -153,7 +159,7 @@ void test_object_commit_parse__parsing_commit_without_message_succeeds(void) "", 0); } -void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) +void test_object_commit_parse__sha1_parsing_commit_with_unknown_fields_succeeds(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -163,7 +169,7 @@ void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) "more garbage\n" "\n" "Message"; - assert_commit_parses(commit, 0, + assert_commit_parses(commit, 0, GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "Author ", "Committer ", @@ -171,7 +177,7 @@ void test_object_commit_parse__parsing_commit_with_unknown_fields_succeeds(void) "Message", 0); } -void test_object_commit_parse__parsing_commit_with_invalid_tree_fails(void) +void test_object_commit_parse__sha1_parsing_commit_with_invalid_tree_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1xxx5f3445895b71d9cb0f8\n" @@ -179,40 +185,51 @@ void test_object_commit_parse__parsing_commit_with_invalid_tree_fails(void) "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_tree_fails(void) +void test_object_commit_parse__sha1_parsing_commit_with_sha256_tree_fails(void) +{ + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA1); +} + +void test_object_commit_parse__sha1_parsing_commit_without_tree_fails(void) { const char *commit = "author Author \n" "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_author_fails(void) +void test_object_commit_parse__sha1_parsing_commit_without_author_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "committer Committer \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_commit_without_committer_fails(void) +void test_object_commit_parse__sha1_parsing_commit_without_committer_fails(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" "author Author \n" "\n" "Message"; - assert_commit_fails(commit, 0); + assert_commit_fails(commit, 0, GIT_OID_SHA1); } -void test_object_commit_parse__parsing_encoding_will_not_cause_oob_read(void) +void test_object_commit_parse__sha1_parsing_encoding_will_not_cause_oob_read(void) { const char *commit = "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" @@ -223,10 +240,237 @@ void test_object_commit_parse__parsing_encoding_will_not_cause_oob_read(void) * As we ignore unknown fields, the cut-off encoding field will be * parsed just fine. */ - assert_commit_parses(commit, strlen(commit) - strlen("ncoding foo\n"), + assert_commit_parses( + commit, strlen(commit) - strlen("ncoding foo\n"), + GIT_OID_SHA1, "3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8", "<>", "<>", NULL, "", 0); } + + +void test_object_commit_parse__sha256_parsing_commit_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "encoding Encoding\n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + "Encoding", + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_encoding_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_multiple_authors_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author1 \n" + "author Author2 \n" + "author Author3 \n" + "author Author4 \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author1 ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_multiple_committers_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer1 \n" + "committer Committer2 \n" + "committer Committer3 \n" + "committer Committer4 \n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer1 ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_message_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_unknown_fields_succeeds(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "foo bar\n" + "more garbage\n" + "\n" + "Message"; + assert_commit_parses(commit, 0, GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "Author ", + "Committer ", + NULL, + "Message", 0); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_invalid_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9adxxxd55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_with_sha1_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree 3e7ac388cadacccdf1c6c5f3445895b71d9cb0f8\n" + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_tree_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "author Author \n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_author_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "committer Committer \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_commit_without_committer_fails(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author Author \n" + "\n" + "Message"; + assert_commit_fails(commit, 0, GIT_OID_SHA256); +#endif +} + +void test_object_commit_parse__sha256_parsing_encoding_will_not_cause_oob_read(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = + "tree f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736\n" + "author <>\n" + "committer <>\n" + "encoding foo\n"; + /* + * As we ignore unknown fields, the cut-off encoding field will be + * parsed just fine. + */ + assert_commit_parses( + commit, strlen(commit) - strlen("ncoding foo\n"), + GIT_OID_SHA256, + "f2a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736", + "<>", + "<>", + NULL, + "", 0); +#endif +} diff --git a/tests/libgit2/object/lookup256.c b/tests/libgit2/object/lookup256.c new file mode 100644 index 000000000..3e1dab661 --- /dev/null +++ b/tests/libgit2/object/lookup256.c @@ -0,0 +1,153 @@ +#include "clar_libgit2.h" + +#include "repository.h" + +#ifdef GIT_EXPERIMENTAL_SHA256 +static git_repository *g_repo; +#endif + +void test_object_lookup256__initialize(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + g_repo = cl_git_sandbox_init("testrepo_256.git"); +#endif +} + +void test_object_lookup256__cleanup(void) +{ +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_sandbox_cleanup(); +#endif +} + +void test_object_lookup256__lookup_wrong_type_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_nonexisting_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *unknown = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, unknown, GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_ANY)); +#endif +} + +void test_object_lookup256__lookup_wrong_type_by_abbreviated_id_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d97"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstrn(&oid, commit, strlen(commit), GIT_OID_SHA256)); + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_wrong_type_eventually_returns_enotfound(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744"; + git_oid oid; + git_object *object; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + git_object_free(object); + + cl_assert_equal_i( + GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG)); +#endif +} + +void test_object_lookup256__lookup_corrupt_object_returns_error(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *commit = "5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848", + *file = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848"; + git_str path = GIT_STR_INIT, contents = GIT_STR_INIT; + git_oid oid; + git_object *object; + size_t i; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + cl_git_pass(git_str_joinpath(&path, git_repository_path(g_repo), file)); + cl_git_pass(git_futils_readbuffer(&contents, path.ptr)); + + /* Corrupt and try to read the object */ + for (i = 0; i < contents.size; i++) { + contents.ptr[i] ^= 0x1; + cl_git_pass(git_futils_writebuffer(&contents, path.ptr, O_RDWR, 0644)); + cl_git_fail(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + contents.ptr[i] ^= 0x1; + } + + /* Restore original content and assert we can read the object */ + cl_git_pass(git_futils_writebuffer(&contents, path.ptr, O_RDWR, 0644)); + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + + git_object_free(object); + git_str_dispose(&path); + git_str_dispose(&contents); +#endif +} + +void test_object_lookup256__lookup_object_with_wrong_hash_returns_error(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + const char *oldloose = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848", + *newloose = "objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26840", + *commit = "5ca8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26840"; + + git_str oldpath = GIT_STR_INIT, newpath = GIT_STR_INIT; + git_object *object; + git_oid oid; + + cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256)); + + /* Copy object to another location with wrong hash */ + cl_git_pass(git_str_joinpath(&oldpath, git_repository_path(g_repo), oldloose)); + cl_git_pass(git_str_joinpath(&newpath, git_repository_path(g_repo), newloose)); + cl_git_pass(git_futils_cp(oldpath.ptr, newpath.ptr, 0644)); + + /* Verify that lookup fails due to a hashsum mismatch */ + cl_git_fail_with(GIT_EMISMATCH, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + + /* Disable verification and try again */ + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0)); + cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT)); + cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 1)); + + git_object_free(object); + git_str_dispose(&oldpath); + git_str_dispose(&newpath); +#endif +} diff --git a/tests/libgit2/object/tag/parse.c b/tests/libgit2/object/tag/parse.c index 92298b5ce..d7a4d85bf 100644 --- a/tests/libgit2/object/tag/parse.c +++ b/tests/libgit2/object/tag/parse.c @@ -14,7 +14,7 @@ static void assert_tag_parses(const char *data, size_t datalen, if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &tag, data, datalen, GIT_OBJECT_TAG)); + cl_git_pass(git_object__from_raw((git_object **) &tag, data, datalen, GIT_OBJECT_TAG, GIT_OID_SHA1)); cl_assert_equal_i(tag->type, GIT_OBJECT_TAG); if (expected_oid) { @@ -54,7 +54,7 @@ static void assert_tag_fails(const char *data, size_t datalen) git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TAG)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TAG, GIT_OID_SHA1)); } void test_object_tag_parse__valid_tag_parses(void) diff --git a/tests/libgit2/object/tree/parse.c b/tests/libgit2/object/tree/parse.c index d6d6e5302..fc985d672 100644 --- a/tests/libgit2/object/tree/parse.c +++ b/tests/libgit2/object/tree/parse.c @@ -26,7 +26,7 @@ static void assert_tree_parses(const char *data, size_t datalen, if (!datalen) datalen = strlen(data); - cl_git_pass(git_object__from_raw((git_object **) &tree, data, datalen, GIT_OBJECT_TREE)); + cl_git_pass(git_object__from_raw((git_object **) &tree, data, datalen, GIT_OBJECT_TREE, GIT_OID_SHA1)); cl_assert_equal_i(git_tree_entrycount(tree), expected_nentries); @@ -51,7 +51,7 @@ static void assert_tree_fails(const char *data, size_t datalen) git_object *object; if (!datalen) datalen = strlen(data); - cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TREE)); + cl_git_fail(git_object__from_raw(&object, data, datalen, GIT_OBJECT_TREE, GIT_OID_SHA1)); } void test_object_tree_parse__single_blob_parses(void) diff --git a/tests/libgit2/object/validate.c b/tests/libgit2/object/validate.c index 87193deb6..e11038115 100644 --- a/tests/libgit2/object/validate.c +++ b/tests/libgit2/object/validate.c @@ -1,50 +1,154 @@ #include "clar_libgit2.h" -#define VALID_COMMIT "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ - "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ - "author Edward Thomson 1638286404 -0500\n" \ - "committer Edward Thomson 1638324642 -0500\n" \ - "\n" \ - "commit go here.\n" -#define VALID_TREE "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" +#define VALID_COMMIT_SHA1 \ + "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ + "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ + "author Edward Thomson 1638286404 -0500\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" -#define INVALID_COMMIT "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ - "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ - "committer Edward Thomson 1638324642 -0500\n" \ - "\n" \ - "commit go here.\n" -#define INVALID_TREE "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" +#define VALID_TREE_SHA1 \ + "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" -void test_object_validate__valid(void) +#define INVALID_COMMIT_SHA1 \ + "tree bdd24e358576f1baa275df98cdcaf3ac9a3f4233\n" \ + "parent d6d956f1d66210bfcd0484166befab33b5987a39\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define INVALID_TREE_SHA1 \ + "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#define VALID_COMMIT_SHA256 \ + "tree d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d\n" \ + "parent 652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b\n" \ + "author Edward Thomson 1638286404 -0500\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define VALID_TREE_SHA256 \ + "100644 HEADER\0\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#define INVALID_COMMIT_SHA256 \ + "tree d0fc7f52dc42358506e7f3f3be72f5271994abb104b9397ab3e19bb42361504d\n" \ + "parent 652412419a24ba62a1d897f40aeb80eecbf873797b04a1bbb8d71918653ef65b\n" \ + "committer Edward Thomson 1638324642 -0500\n" \ + "\n" \ + "commit go here.\n" + +#define INVALID_TREE_SHA256 \ + "100644 HEADER \x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42\x42" + +#ifdef GIT_EXPERIMENTAL_SHA256 +# define sha1_rawcontent_is_valid(v, c, l, t) \ + git_object_rawcontent_is_valid(v, c, l, t, GIT_OID_SHA1) +#else +# define sha1_rawcontent_is_valid(v, c, l, t) \ + git_object_rawcontent_is_valid(v, c, l, t) +#endif + +void test_object_validate__valid_sha1(void) { int valid; - cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT, CONST_STRLEN(VALID_COMMIT), GIT_OBJECT_COMMIT)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_COMMIT_SHA1, CONST_STRLEN(VALID_COMMIT_SHA1), GIT_OBJECT_COMMIT)); cl_assert_equal_i(1, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_TREE, CONST_STRLEN(VALID_TREE), GIT_OBJECT_TREE)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_TREE_SHA1, CONST_STRLEN(VALID_TREE_SHA1), GIT_OBJECT_TREE)); cl_assert_equal_i(1, valid); } -void test_object_validate__invalid(void) +void test_object_validate__cannot_parse_sha256_as_sha1(void) { int valid; - cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, VALID_COMMIT_SHA256, CONST_STRLEN(INVALID_COMMIT_SHA256), GIT_OBJECT_COMMIT)); cl_assert_equal_i(0, valid); - cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT)); - cl_assert_equal_i(0, valid); - - cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_COMMIT, CONST_STRLEN(INVALID_COMMIT), GIT_OBJECT_COMMIT)); - cl_assert_equal_i(0, valid); - - cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE, CONST_STRLEN(INVALID_TREE), GIT_OBJECT_TREE)); + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_TREE_SHA256, CONST_STRLEN(INVALID_TREE_SHA256), GIT_OBJECT_TREE)); cl_assert_equal_i(0, valid); } + +void test_object_validate__invalid_sha1(void) +{ + int valid; + + cl_git_pass(sha1_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_COMMIT_SHA1, CONST_STRLEN(INVALID_COMMIT_SHA1), GIT_OBJECT_COMMIT)); + cl_assert_equal_i(0, valid); + + cl_git_pass(sha1_rawcontent_is_valid(&valid, INVALID_TREE_SHA1, CONST_STRLEN(INVALID_TREE_SHA1), GIT_OBJECT_TREE)); + cl_assert_equal_i(0, valid); +} + + +void test_object_validate__valid_sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + int valid; + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_BLOB, GIT_OID_SHA256)); + cl_assert_equal_i(1, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_BLOB, GIT_OID_SHA256)); + cl_assert_equal_i(1, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT_SHA256, CONST_STRLEN(VALID_COMMIT_SHA256), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(1, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_TREE_SHA256, CONST_STRLEN(VALID_TREE_SHA256), GIT_OBJECT_TREE, GIT_OID_SHA256)); + cl_assert_equal_i(1, valid); +#endif +} + +void test_object_validate__invalid_sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + int valid; + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "", 0, GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, "foobar", 0, GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_COMMIT_SHA256, CONST_STRLEN(INVALID_COMMIT_SHA256), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE_SHA256, CONST_STRLEN(INVALID_TREE_SHA256), GIT_OBJECT_TREE, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); +#endif +} + +void test_object_validate__cannot_parse_sha1_as_sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + int valid; + + cl_git_pass(git_object_rawcontent_is_valid(&valid, VALID_COMMIT_SHA1, CONST_STRLEN(INVALID_COMMIT_SHA1), GIT_OBJECT_COMMIT, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); + + cl_git_pass(git_object_rawcontent_is_valid(&valid, INVALID_TREE_SHA1, CONST_STRLEN(INVALID_TREE_SHA1), GIT_OBJECT_TREE, GIT_OID_SHA256)); + cl_assert_equal_i(0, valid); +#endif +} diff --git a/tests/libgit2/pack/indexer.c b/tests/libgit2/pack/indexer.c index 2ac287255..9722decaf 100644 --- a/tests/libgit2/pack/indexer.c +++ b/tests/libgit2/pack/indexer.c @@ -100,7 +100,12 @@ void test_pack_indexer__out_of_order(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, out_of_order_pack, out_of_order_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -117,7 +122,12 @@ void test_pack_indexer__missing_trailer(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, missing_trailer_pack, missing_trailer_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -133,7 +143,12 @@ void test_pack_indexer__leaky(void) git_indexer *idx = 0; git_indexer_progress stats = { 0 }; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_indexer_append( idx, leaky_pack, leaky_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -151,6 +166,7 @@ void test_pack_indexer__fix_thin(void) git_repository *repo; git_odb *odb; git_oid id, should_id; + git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; cl_git_pass(git_repository_init(&repo, "thin.git", true)); cl_git_pass(git_repository_odb(&odb, repo)); @@ -160,7 +176,13 @@ void test_pack_indexer__fix_thin(void) git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1); cl_assert_equal_oid(&should_id, &id); - cl_git_pass(git_indexer_new(&idx, ".", 0, odb, NULL)); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else + cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts)); +#endif + cl_git_pass(git_indexer_append(idx, thin_pack, thin_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -192,7 +214,12 @@ void test_pack_indexer__fix_thin(void) cl_git_pass(p_stat(name, &st)); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + read = p_read(fd, buffer, sizeof(buffer)); cl_assert(read != -1); p_close(fd); @@ -216,6 +243,7 @@ void test_pack_indexer__corrupt_length(void) git_repository *repo; git_odb *odb; git_oid id, should_id; + git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT; cl_git_pass(git_repository_init(&repo, "thin.git", true)); cl_git_pass(git_repository_odb(&odb, repo)); @@ -225,7 +253,13 @@ void test_pack_indexer__corrupt_length(void) git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1); cl_assert_equal_oid(&should_id, &id); - cl_git_pass(git_indexer_new(&idx, ".", 0, odb, NULL)); +#ifdef GIT_EXPERIMENTAL_SHA256 + opts.odb = odb; + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else + cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, corrupt_thin_pack, corrupt_thin_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -246,7 +280,12 @@ void test_pack_indexer__incomplete_pack_fails_with_strict(void) opts.verify = 1; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, incomplete_pack, incomplete_pack_len, &stats)); cl_git_fail(git_indexer_commit(idx, &stats)); @@ -266,7 +305,12 @@ void test_pack_indexer__out_of_order_with_connectivity_checks(void) opts.verify = 1; +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts)); +#endif + cl_git_pass(git_indexer_append( idx, out_of_order_pack, out_of_order_pack_len, &stats)); cl_git_pass(git_indexer_commit(idx, &stats)); @@ -309,7 +353,12 @@ void test_pack_indexer__no_tmp_files(void) git_str_dispose(&path); cl_assert(git_str_len(&first_tmp_file) == 0); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + git_indexer_free(idx); cl_git_pass(git_str_sets(&path, clar_sandbox_path())); diff --git a/tests/libgit2/pack/packbuilder.c b/tests/libgit2/pack/packbuilder.c index 0889f46ed..ff3dc1f68 100644 --- a/tests/libgit2/pack/packbuilder.c +++ b/tests/libgit2/pack/packbuilder.c @@ -104,7 +104,12 @@ void test_pack_packbuilder__create_pack(void) seed_packbuilder(); +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&_indexer, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&_indexer, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_packbuilder_foreach(_packbuilder, feed_indexer, &stats)); cl_git_pass(git_indexer_commit(_indexer, &stats)); @@ -244,7 +249,13 @@ void test_pack_packbuilder__foreach(void) git_indexer *idx; seed_packbuilder(); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_pass(git_packbuilder_foreach(_packbuilder, foreach_cb, idx)); cl_git_pass(git_indexer_commit(idx, &_stats)); git_indexer_free(idx); @@ -262,7 +273,13 @@ void test_pack_packbuilder__foreach_with_cancel(void) git_indexer *idx; seed_packbuilder(); + +#ifdef GIT_EXPERIMENTAL_SHA256 + cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL)); +#else cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL)); +#endif + cl_git_fail_with( git_packbuilder_foreach(_packbuilder, foreach_cancel_cb, idx), -1111); git_indexer_free(idx); From e56f35076e0b669d6b226eb3b8808d84899e425b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 08:17:34 -0400 Subject: [PATCH 12/22] refdb: teach filesystem refdb about sha256 --- src/libgit2/refdb_fs.c | 109 ++++++++++++++++++++++++++--------------- src/libgit2/reflog.c | 14 +++--- src/libgit2/reflog.h | 3 +- 3 files changed, 78 insertions(+), 48 deletions(-) diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c index 43283b3e4..9ce1a9608 100644 --- a/src/libgit2/refdb_fs.c +++ b/src/libgit2/refdb_fs.c @@ -60,15 +60,17 @@ typedef struct refdb_fs_backend { /* path to common objects' directory */ char *commonpath; - git_sortedcache *refcache; + git_oid_t oid_type; + + int fsync : 1, + sorted : 1; int peeling_mode; git_iterator_flag_t iterator_flags; uint32_t direach_flags; - int fsync; + git_sortedcache *refcache; git_map packed_refs_map; git_mutex prlock; /* protect packed_refs_map */ git_futils_filestamp packed_refs_stamp; - bool sorted; } refdb_fs_backend; static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name); @@ -113,6 +115,7 @@ static int packed_reload(refdb_fs_backend *backend) { int error; git_str packedrefs = GIT_STR_INIT; + size_t oid_hexsize = git_oid_hexsize(backend->oid_type); char *scan, *eof, *eol; if (!backend->gitpath) @@ -158,9 +161,9 @@ static int packed_reload(refdb_fs_backend *backend) /* parse " \n" */ - if (git_oid__fromstr(&oid, scan, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(&oid, scan, backend->oid_type) < 0) goto parse_failed; - scan += GIT_OID_SHA1_HEXSIZE; + scan += oid_hexsize; if (*scan++ != ' ') goto parse_failed; @@ -179,9 +182,9 @@ static int packed_reload(refdb_fs_backend *backend) /* look for optional "^\n" */ if (*scan == '^') { - if (git_oid__fromstr(&oid, scan + 1, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(&oid, scan + 1, backend->oid_type) < 0) goto parse_failed; - scan += GIT_OID_SHA1_HEXSIZE + 1; + scan += oid_hexsize + 1; if (scan < eof) { if (!(eol = strchr(scan, '\n'))) @@ -214,19 +217,23 @@ parse_failed: } static int loose_parse_oid( - git_oid *oid, const char *filename, git_str *file_content) + git_oid *oid, + const char *filename, + git_str *file_content, + git_oid_t oid_type) { const char *str = git_str_cstr(file_content); + size_t oid_hexsize = git_oid_hexsize(oid_type); - if (git_str_len(file_content) < GIT_OID_SHA1_HEXSIZE) + if (git_str_len(file_content) < oid_hexsize) goto corrupted; /* we need to get 40 OID characters from the file */ - if (git_oid__fromstr(oid, str, GIT_OID_SHA1) < 0) + if (git_oid__fromstr(oid, str, oid_type) < 0) goto corrupted; /* If the file is longer than 40 chars, the 41st must be a space */ - str += GIT_OID_SHA1_HEXSIZE; + str += oid_hexsize; if (*str == '\0' || git__isspace(*str)) return 0; @@ -266,7 +273,7 @@ static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name) goto done; /* parse OID from file */ - if ((error = loose_parse_oid(&oid, name, &ref_file)) < 0) + if ((error = loose_parse_oid(&oid, name, &ref_file, backend->oid_type)) < 0) goto done; if ((error = git_sortedcache_wlock(backend->refcache)) < 0) @@ -437,7 +444,7 @@ static int loose_lookup( } else { git_oid oid; - if (!(error = loose_parse_oid(&oid, ref_name, &ref_file)) && + if (!(error = loose_parse_oid(&oid, ref_name, &ref_file, backend->oid_type)) && out != NULL) *out = git_reference__alloc(ref_name, &oid, NULL); } @@ -615,19 +622,24 @@ static const char *end_of_record(const char *p, const char *end) return p; } -static int -cmp_record_to_refname(const char *rec, size_t data_end, const char *ref_name) +static int cmp_record_to_refname( + const char *rec, + size_t data_end, + const char *ref_name, + git_oid_t oid_type) { const size_t ref_len = strlen(ref_name); int cmp_val; const char *end; + size_t oid_hexsize = git_oid_hexsize(oid_type); - rec += GIT_OID_SHA1_HEXSIZE + 1; /* + space */ - if (data_end < GIT_OID_SHA1_HEXSIZE + 3) { - /* an incomplete (corrupt) record is treated as less than ref_name */ + rec += oid_hexsize + 1; /* + space */ + + /* an incomplete (corrupt) record is treated as less than ref_name */ + if (data_end < oid_hexsize + 3) return -1; - } - data_end -= GIT_OID_SHA1_HEXSIZE + 1; + + data_end -= oid_hexsize + 1; end = memchr(rec, '\n', data_end); if (end) @@ -675,6 +687,7 @@ static int packed_lookup( { int error = 0; const char *left, *right, *data_end; + size_t oid_hexsize = git_oid_hexsize(backend->oid_type); if ((error = packed_map_check(backend)) < 0) return error; @@ -698,7 +711,7 @@ static int packed_lookup( mid = left + (right - left) / 2; rec = start_of_record(left, mid); - compare = cmp_record_to_refname(rec, data_end - rec, ref_name); + compare = cmp_record_to_refname(rec, data_end - rec, ref_name, backend->oid_type); if (compare < 0) { left = end_of_record(mid, right); @@ -708,11 +721,11 @@ static int packed_lookup( const char *eol; git_oid oid, peel, *peel_ptr = NULL; - if (data_end - rec < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&oid, rec, GIT_OID_SHA1) < 0) { + if (data_end - rec < (long)oid_hexsize || + git_oid__fromstr(&oid, rec, backend->oid_type) < 0) { goto parse_failed; } - rec += GIT_OID_SHA1_HEXSIZE + 1; + rec += oid_hexsize + 1; if (!(eol = memchr(rec, '\n', data_end - rec))) { goto parse_failed; } @@ -724,8 +737,8 @@ static int packed_lookup( if (*rec == '^') { rec++; - if (data_end - rec < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&peel, rec, GIT_OID_SHA1) < 0) { + if (data_end - rec < (long)oid_hexsize || + git_oid__fromstr(&peel, rec, backend->oid_type) < 0) { goto parse_failed; } peel_ptr = &peel; @@ -1108,7 +1121,7 @@ static int loose_commit(git_filebuf *file, const git_reference *ref) GIT_ASSERT_ARG(ref); if (ref->type == GIT_REFERENCE_DIRECT) { - char oid[GIT_OID_SHA1_HEXSIZE + 1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(oid, sizeof(oid), &ref->target.oid); git_filebuf_printf(file, "%s\n", oid); @@ -1224,7 +1237,7 @@ static int packed_find_peel(refdb_fs_backend *backend, struct packref *ref) */ static int packed_write_ref(struct packref *ref, git_filebuf *file) { - char oid[GIT_OID_SHA1_HEXSIZE + 1]; + char oid[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(oid, sizeof(oid), &ref->oid); /* @@ -1238,7 +1251,7 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) * The required peels have already been loaded into `ref->peel_target`. */ if (ref->flags & PACKREF_HAS_PEEL) { - char peel[GIT_OID_SHA1_HEXSIZE + 1]; + char peel[GIT_OID_MAX_HEXSIZE + 1]; git_oid_nfmt(peel, sizeof(peel), &ref->peel); if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0) @@ -1302,7 +1315,7 @@ static int packed_remove_loose(refdb_fs_backend *backend) continue; /* Figure out the current id; if we find a bad ref file, skip it so we can do the rest */ - if (loose_parse_oid(¤t_id, lock.path_original, &ref_content) < 0) + if (loose_parse_oid(¤t_id, lock.path_original, &ref_content, backend->oid_type) < 0) continue; /* If the ref moved since we packed it, we must not delete it */ @@ -1891,7 +1904,10 @@ done: return out; } -static int reflog_alloc(git_reflog **reflog, const char *name) +static int reflog_alloc( + git_reflog **reflog, + const char *name, + git_oid_t oid_type) { git_reflog *log; @@ -1903,6 +1919,8 @@ static int reflog_alloc(git_reflog **reflog, const char *name) log->ref_name = git__strdup(name); GIT_ERROR_CHECK_ALLOC(log->ref_name); + log->oid_type = oid_type; + if (git_vector_init(&log->entries, 0, NULL) < 0) { git__free(log->ref_name); git__free(log); @@ -2032,7 +2050,10 @@ static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *nam return has_reflog(backend->repo, name); } -static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name) +static int refdb_reflog_fs__read( + git_reflog **out, + git_refdb_backend *_backend, + const char *name) { int error = -1; git_str log_path = GIT_STR_INIT; @@ -2048,7 +2069,7 @@ static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, backend = GIT_CONTAINER_OF(_backend, refdb_fs_backend, parent); repo = backend->repo; - if (reflog_alloc(&log, name) < 0) + if (reflog_alloc(&log, name, backend->oid_type) < 0) return -1; if (reflog_path(&log_path, repo, name) < 0) @@ -2086,11 +2107,11 @@ static int serialize_reflog_entry( const git_signature *committer, const char *msg) { - char raw_old[GIT_OID_SHA1_HEXSIZE+1]; - char raw_new[GIT_OID_SHA1_HEXSIZE+1]; + char raw_old[GIT_OID_MAX_HEXSIZE + 1]; + char raw_new[GIT_OID_MAX_HEXSIZE + 1]; - git_oid_tostr(raw_old, GIT_OID_SHA1_HEXSIZE+1, oid_old); - git_oid_tostr(raw_new, GIT_OID_SHA1_HEXSIZE+1, oid_new); + git_oid_tostr(raw_old, GIT_OID_MAX_HEXSIZE + 1, oid_old); + git_oid_tostr(raw_new, GIT_OID_MAX_HEXSIZE + 1, oid_new); git_str_clear(buf); @@ -2189,10 +2210,16 @@ success: } /* Append to the reflog, must be called under reference lock */ -static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message) +static int reflog_append( + refdb_fs_backend *backend, + const git_reference *ref, + const git_oid *old, + const git_oid *new, + const git_signature *who, + const char *message) { int error, is_symbolic, open_flags; - git_oid old_id = GIT_OID_SHA1_ZERO, new_id = GIT_OID_SHA1_ZERO; + git_oid old_id, new_id; git_str buf = GIT_STR_INIT, path = GIT_STR_INIT; git_repository *repo = backend->repo; @@ -2206,6 +2233,9 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co /* From here on is_symbolic also means that it's HEAD */ + git_oid_clear(&old_id, backend->oid_type); + git_oid_clear(&new_id, backend->oid_type); + if (old) { git_oid_cpy(&old_id, old); } else { @@ -2402,6 +2432,7 @@ int git_refdb_backend_fs( goto fail; backend->repo = repository; + backend->oid_type = repository->oid_type; if (repository->gitdir) { backend->gitpath = setup_namespace(repository, repository->gitdir); diff --git a/src/libgit2/reflog.c b/src/libgit2/reflog.c index eb0b7e48c..86d4355e3 100644 --- a/src/libgit2/reflog.c +++ b/src/libgit2/reflog.c @@ -71,7 +71,11 @@ int git_reflog_write(git_reflog *reflog) return db->backend->reflog_write(db->backend, reflog); } -int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg) +int git_reflog_append( + git_reflog *reflog, + const git_oid *new_oid, + const git_signature *committer, + const char *msg) { const git_reflog_entry *previous; git_reflog_entry *entry; @@ -104,7 +108,7 @@ int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_sign previous = git_reflog_entry_byindex(reflog, 0); if (previous == NULL) - git_oid__fromstr(&entry->oid_old, GIT_OID_SHA1_HEXZERO, GIT_OID_SHA1); + git_oid_clear(&entry->oid_old, reflog->oid_type); else git_oid_cpy(&entry->oid_old, &previous->oid_cur); @@ -218,12 +222,8 @@ int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry) /* If the oldest entry has just been removed... */ if (idx == entrycount - 1) { - git_oid zero = GIT_OID_SHA1_ZERO; - /* ...clear the oid_old member of the "new" oldest entry */ - if (git_oid_cpy(&entry->oid_old, &zero) < 0) - return -1; - + git_oid_clear(&entry->oid_old, reflog->oid_type); return 0; } diff --git a/src/libgit2/reflog.h b/src/libgit2/reflog.h index 50d1056ed..bc9878598 100644 --- a/src/libgit2/reflog.h +++ b/src/libgit2/reflog.h @@ -16,8 +16,6 @@ #define GIT_REFLOG_DIR_MODE 0777 #define GIT_REFLOG_FILE_MODE 0666 -#define GIT_REFLOG_SIZE_MIN (2*GIT_OID_SHA1_HEXSIZE+2+17) - struct git_reflog_entry { git_oid oid_old; git_oid oid_cur; @@ -30,6 +28,7 @@ struct git_reflog_entry { struct git_reflog { git_refdb *db; char *ref_name; + git_oid_t oid_type; git_vector entries; }; From 7186d7baadfe3e5e129710e07bdd57b1c7c0e862 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 21 Sep 2022 08:25:58 -0400 Subject: [PATCH 13/22] revparse: don't assume SHA1 --- src/libgit2/revparse.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c index 2ed282159..bd13727eb 100644 --- a/src/libgit2/revparse.c +++ b/src/libgit2/revparse.c @@ -15,21 +15,28 @@ #include "git2.h" -static int maybe_sha_or_abbrev(git_object **out, git_repository *repo, const char *spec, size_t speclen) +static int maybe_sha_or_abbrev( + git_object **out, + git_repository *repo, + const char *spec, + size_t speclen) { git_oid oid; - if (git_oid__fromstrn(&oid, spec, speclen, GIT_OID_SHA1) < 0) + if (git_oid__fromstrn(&oid, spec, speclen, repo->oid_type) < 0) return GIT_ENOTFOUND; return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJECT_ANY); } -static int maybe_sha(git_object **out, git_repository *repo, const char *spec) +static int maybe_sha( + git_object **out, + git_repository *repo, + const char *spec) { size_t speclen = strlen(spec); - if (speclen != GIT_OID_SHA1_HEXSIZE) + if (speclen != git_oid_hexsize(repo->oid_type)) return GIT_ENOTFOUND; return maybe_sha_or_abbrev(out, repo, spec, speclen); @@ -110,8 +117,8 @@ static int revparse_lookup_object( if (error != GIT_ENOTFOUND) return error; - if ((strlen(spec) < GIT_OID_SHA1_HEXSIZE) && - ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND)) + if ((strlen(spec) < git_oid_hexsize(repo->oid_type)) && + ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND)) return error; if ((error = maybe_describe(object_out, repo, spec)) != GIT_ENOTFOUND) From 0006ff63359358bc5e65ea5a2b6ef7ba5eca2e8e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Wed, 23 Nov 2022 22:05:29 +0000 Subject: [PATCH 14/22] clone: support sha256 --- ci/test.sh | 19 ++++ src/libgit2/transports/smart.h | 7 +- src/libgit2/transports/smart_pkt.c | 111 ++++++++++++++++++++---- src/libgit2/transports/smart_protocol.c | 13 ++- tests/libgit2/CMakeLists.txt | 1 + tests/libgit2/online/clone.c | 19 ++++ tests/libgit2/transports/smart/packet.c | 37 +++++--- 7 files changed, 173 insertions(+), 34 deletions(-) diff --git a/ci/test.sh b/ci/test.sh index 230daaaa0..95e6871e7 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -32,6 +32,11 @@ cleanup() { kill $GIT_NAMESPACE_PID fi + if [ ! -z "$GIT_SHA256_PID" ]; then + echo "Stopping git daemon (sha256)..." + kill $GIT_SHA256_PID + fi + if [ ! -z "$PROXY_BASIC_PID" ]; then echo "Stopping proxy (Basic)..." kill $PROXY_BASIC_PID @@ -114,6 +119,12 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then cp -R "${SOURCE_DIR}/tests/resources/namespace.git" "${GIT_NAMESPACE_DIR}/namespace.git" GIT_NAMESPACE="name1" git daemon --listen=localhost --port=9419 --export-all --enable=receive-pack --base-path="${GIT_NAMESPACE_DIR}" "${GIT_NAMESPACE_DIR}" & GIT_NAMESPACE_PID=$! + + echo "Starting git daemon (sha256)..." + GIT_SHA256_DIR=`mktemp -d ${TMPDIR}/git_sha256.XXXXXXXX` + cp -R "${SOURCE_DIR}/tests/resources/testrepo_256.git" "${GIT_SHA256_DIR}/testrepo_256.git" + git daemon --listen=localhost --port=9420 --export-all --enable=receive-pack --base-path="${GIT_SHA256_DIR}" "${GIT_SHA256_DIR}" & + GIT_SHA256_PID=$! fi if [ -z "$SKIP_PROXY_TESTS" ]; then @@ -261,6 +272,14 @@ if [ -z "$SKIP_GITDAEMON_TESTS" ]; then run_test gitdaemon_namespace unset GITTEST_REMOTE_URL unset GITTEST_REMOTE_BRANCH + + echo "" + echo "Running gitdaemon (sha256) tests" + echo "" + + export GITTEST_REMOTE_URL="git://localhost:9420/testrepo_256.git" + run_test gitdaemon_sha256 + unset GITTEST_REMOTE_URL fi if [ -z "$SKIP_PROXY_TESTS" ]; then diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index 9323d6c44..ca6496163 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -182,7 +182,12 @@ int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream int git_smart__update_heads(transport_smart *t, git_vector *symrefs); /* smart_pkt.c */ -int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen); +typedef struct { + git_oid_t oid_type; + int seen_capabilities: 1; +} git_pkt_parse_data; + +int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data); int git_pkt_buffer_flush(git_str *buf); int git_pkt_send_flush(GIT_SOCKET s); int git_pkt_buffer_done(git_str *buf); diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index e679819fa..b6428d845 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -212,26 +212,87 @@ static int sideband_error_pkt(git_pkt **out, const char *line, size_t len) return 0; } +static int set_data( + git_pkt_parse_data *data, + const char *line, + size_t len) +{ + const char *caps, *format_str = NULL, *eos; + size_t format_len; + git_oid_t remote_oid_type; + + GIT_ASSERT_ARG(data); + + if ((caps = memchr(line, '\0', len)) != NULL) { + caps++; + + if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0) + format_str = caps + CONST_STRLEN("object-format="); + else if ((format_str = strstr(caps, " object-format=")) != NULL) + format_str += CONST_STRLEN(" object-format="); + } + + if (format_str) { + if ((eos = strchr(format_str, ' ')) == NULL) + eos = strchr(format_str, '\0'); + + GIT_ASSERT(eos); + + format_len = eos - format_str; + + if ((remote_oid_type = git_oid_type_fromstrn(format_str, format_len)) == 0) { + git_error_set(GIT_ERROR_INVALID, "unknown remote object format '%.*s'", (int)format_len, format_str); + return -1; + } + } else { + remote_oid_type = GIT_OID_SHA1; + } + + if (!data->oid_type) { + data->oid_type = remote_oid_type; + } else if (data->oid_type != remote_oid_type) { + git_error_set(GIT_ERROR_INVALID, + "the local object format '%s' does not match the remote object format '%s'", + git_oid_type_name(data->oid_type), + git_oid_type_name(remote_oid_type)); + return -1; + } + + return 0; +} + /* * Parse an other-ref line. */ -static int ref_pkt(git_pkt **out, const char *line, size_t len) +static int ref_pkt( + git_pkt **out, + const char *line, + size_t len, + git_pkt_parse_data *data) { git_pkt_ref *pkt; - size_t alloclen; + size_t alloclen, oid_hexsize; pkt = git__calloc(1, sizeof(git_pkt_ref)); GIT_ERROR_CHECK_ALLOC(pkt); pkt->type = GIT_PKT_REF; - if (len < GIT_OID_SHA1_HEXSIZE || - git_oid__fromstr(&pkt->head.oid, line, GIT_OID_SHA1) < 0) + /* Determine OID type from capabilities */ + if (!data->seen_capabilities && set_data(data, line, len) < 0) + return -1; + + GIT_ASSERT(data->oid_type); + oid_hexsize = git_oid_hexsize(data->oid_type); + + if (len < oid_hexsize || + git_oid__fromstr(&pkt->head.oid, line, data->oid_type) < 0) goto out_err; - line += GIT_OID_SHA1_HEXSIZE; - len -= GIT_OID_SHA1_HEXSIZE; + line += oid_hexsize; + len -= oid_hexsize; if (git__prefixncmp(line, len, " ")) goto out_err; + line++; len--; @@ -248,8 +309,14 @@ static int ref_pkt(git_pkt **out, const char *line, size_t len) memcpy(pkt->head.name, line, len); pkt->head.name[len] = '\0'; - if (strlen(pkt->head.name) < len) - pkt->capabilities = strchr(pkt->head.name, '\0') + 1; + if (strlen(pkt->head.name) < len) { + if (!data->seen_capabilities) + pkt->capabilities = strchr(pkt->head.name, '\0') + 1; + else + goto out_err; + } + + data->seen_capabilities = 1; *out = (git_pkt *)pkt; return 0; @@ -418,7 +485,11 @@ static int parse_len(size_t *out, const char *line, size_t linelen) */ int git_pkt_parse_line( - git_pkt **pkt, const char **endptr, const char *line, size_t linelen) + git_pkt **pkt, + const char **endptr, + const char *line, + size_t linelen, + git_pkt_parse_data *data) { int error; size_t len; @@ -493,7 +564,7 @@ int git_pkt_parse_line( else if (!git__prefixncmp(line, len, "unpack")) error = unpack_pkt(pkt, line, len); else - error = ref_pkt(pkt, line, len); + error = ref_pkt(pkt, line, len, data); *endptr = line + len; @@ -533,8 +604,11 @@ int git_pkt_buffer_flush(git_str *buf) static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_str *buf) { git_str str = GIT_STR_INIT; - char oid[GIT_OID_SHA1_HEXSIZE +1] = {0}; - size_t len; + char oid[GIT_OID_MAX_HEXSIZE + 1] = {0}; + size_t oid_hexsize, len; + + oid_hexsize = git_oid_hexsize(head->oid.type); + git_oid_fmt(oid, &head->oid); /* Prefer multi_ack_detailed */ if (caps->multi_ack_detailed) @@ -560,7 +634,7 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca if (git_str_oom(&str)) return -1; - len = strlen("XXXXwant ") + GIT_OID_SHA1_HEXSIZE + 1 /* NUL */ + + len = strlen("XXXXwant ") + oid_hexsize + 1 /* NUL */ + git_str_len(&str) + 1 /* LF */; if (len > 0xffff) { @@ -570,9 +644,9 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca } git_str_grow_by(buf, len); - git_oid_fmt(oid, &head->oid); git_str_printf(buf, - "%04xwant %s %s\n", (unsigned int)len, oid, git_str_cstr(&str)); + "%04xwant %.*s %s\n", (unsigned int)len, + (int)oid_hexsize, oid, git_str_cstr(&str)); git_str_dispose(&str); GIT_ERROR_CHECK_ALLOC_STR(buf); @@ -608,16 +682,19 @@ int git_pkt_buffer_wants( } for (; i < count; ++i) { - char oid[GIT_OID_SHA1_HEXSIZE]; + char oid[GIT_OID_MAX_HEXSIZE]; head = refs[i]; + if (head->local) continue; git_oid_fmt(oid, &head->oid); + git_str_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - git_str_put(buf, oid, GIT_OID_SHA1_HEXSIZE); + git_str_put(buf, oid, git_oid_hexsize(head->oid.type)); git_str_putc(buf, '\n'); + if (git_str_oom(buf)) return -1; } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 88c208fb5..86d02df83 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -32,6 +32,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) int error, flush = 0, recvd; const char *line_end = NULL; git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; size_t i; /* Clear existing refs in case git_remote_connect() is called again @@ -45,7 +46,7 @@ int git_smart__store_refs(transport_smart *t, int flushes) do { if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset); + error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset, &pkt_parse_data); else error = GIT_EBUFS; @@ -228,11 +229,12 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf { const char *ptr = buf->data, *line_end = ptr; git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; int error = 0, ret; do { if (buf->offset > 0) - error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset); + error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset, &pkt_parse_data); else error = GIT_EBUFS; @@ -723,6 +725,7 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt) static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_str *data_pkt_buf) { git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; const char *line, *line_end = NULL; size_t line_len; int error; @@ -741,7 +744,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, } while (line_len > 0) { - error = git_pkt_parse_line(&pkt, &line_end, line, line_len); + error = git_pkt_parse_line(&pkt, &line_end, line, line_len, &pkt_parse_data); if (error == GIT_EBUFS) { /* Buffer the data when the inner packet is split @@ -777,6 +780,7 @@ done: static int parse_report(transport_smart *transport, git_push *push) { git_pkt *pkt = NULL; + git_pkt_parse_data pkt_parse_data = { 0 }; const char *line_end = NULL; gitno_buffer *buf = &transport->buffer; int error, recvd; @@ -785,7 +789,8 @@ static int parse_report(transport_smart *transport, git_push *push) for (;;) { if (buf->offset > 0) error = git_pkt_parse_line(&pkt, &line_end, - buf->data, buf->offset); + buf->data, buf->offset, + &pkt_parse_data); else error = GIT_EBUFS; diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt index f581d3075..6cce150de 100644 --- a/tests/libgit2/CMakeLists.txt +++ b/tests/libgit2/CMakeLists.txt @@ -70,6 +70,7 @@ add_clar_test(libgit2_tests online -v -sonline -xonline::customcert add_clar_test(libgit2_tests online_customcert -v -sonline::customcert) add_clar_test(libgit2_tests gitdaemon -v -sonline::push) add_clar_test(libgit2_tests gitdaemon_namespace -v -sonline::clone::namespace) +add_clar_test(libgit2_tests gitdaemon_sha256 -v -sonline::clone::sha256) add_clar_test(libgit2_tests ssh -v -sonline::push -sonline::clone::ssh_cert -sonline::clone::ssh_with_paths -sonline::clone::path_whitespace_ssh -sonline::clone::ssh_auth_methods) add_clar_test(libgit2_tests proxy -v -sonline::clone::proxy) add_clar_test(libgit2_tests auth_clone -v -sonline::clone::cred) diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c index 96ff66ae0..70ec4ef1a 100644 --- a/tests/libgit2/online/clone.c +++ b/tests/libgit2/online/clone.c @@ -1058,3 +1058,22 @@ void test_online_clone__namespace_with_specified_branch(void) git_reference_free(head); } + +void test_online_clone__sha256(void) +{ +#ifndef GIT_EXPERIMENTAL_SHA256 + cl_skip(); +#else + git_clone_options options = GIT_CLONE_OPTIONS_INIT; + git_reference *head; + + if (!_remote_url) + cl_skip(); + + cl_git_pass(git_clone(&g_repo, _remote_url, "./sha256", &options)); + cl_git_pass(git_reference_lookup(&head, g_repo, GIT_HEAD_FILE)); + cl_assert_equal_i(GIT_REFERENCE_SYMBOLIC, git_reference_type(head)); + + git_reference_free(head); +#endif +} diff --git a/tests/libgit2/transports/smart/packet.c b/tests/libgit2/transports/smart/packet.c index 8801ef833..2035e3b65 100644 --- a/tests/libgit2/transports/smart/packet.c +++ b/tests/libgit2/transports/smart/packet.c @@ -11,8 +11,9 @@ static void assert_flush_parses(const char *line) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_FLUSH); cl_assert_equal_strn(endptr, line + 4, linelen - 4); @@ -24,8 +25,9 @@ static void assert_data_pkt_parses(const char *line, const char *expected_data, size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_data *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_DATA); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->data, expected_data, expected_len); @@ -38,8 +40,9 @@ static void assert_sideband_progress_parses(const char *line, const char *expect size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_progress *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_PROGRESS); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->data, expected_data, expected_len); @@ -52,8 +55,9 @@ static void assert_error_parses(const char *line, const char *expected_error, si size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_err *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_ERR); cl_assert_equal_i(pkt->len, expected_len); cl_assert_equal_strn(pkt->error, expected_error, expected_len); @@ -67,10 +71,11 @@ static void assert_ack_parses(const char *line, const char *expected_oid, enum g const char *endptr; git_pkt_ack *pkt; git_oid oid; + git_pkt_parse_data pkt_parse_data = { 0 }; cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1)); - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_ACK); cl_assert_equal_oid(&pkt->oid, &oid); cl_assert_equal_i(pkt->status, expected_status); @@ -83,8 +88,9 @@ static void assert_nak_parses(const char *line) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_NAK); cl_assert_equal_strn(endptr, line + 7, linelen - 7); @@ -96,8 +102,9 @@ static void assert_comment_parses(const char *line, const char *expected_comment size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_comment *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_COMMENT); cl_assert_equal_strn(pkt->comment, expected_comment, strlen(expected_comment)); @@ -109,8 +116,9 @@ static void assert_ok_parses(const char *line, const char *expected_ref) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_ok *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_OK); cl_assert_equal_strn(pkt->ref, expected_ref, strlen(expected_ref)); @@ -122,8 +130,9 @@ static void assert_unpack_parses(const char *line, bool ok) size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_unpack *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_UNPACK); cl_assert_equal_i(pkt->unpack_ok, ok); @@ -135,8 +144,9 @@ static void assert_ng_parses(const char *line, const char *expected_ref, const c size_t linelen = strlen(line) + 1; const char *endptr; git_pkt_ng *pkt; + git_pkt_parse_data pkt_parse_data = { 0 }; - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_NG); cl_assert_equal_strn(pkt->ref, expected_ref, strlen(expected_ref)); cl_assert_equal_strn(pkt->msg, expected_msg, strlen(expected_msg)); @@ -153,10 +163,11 @@ static void assert_ref_parses_(const char *line, size_t linelen, const char *exp const char *endptr; git_pkt_ref *pkt; git_oid oid; + git_pkt_parse_data pkt_parse_data = { 0 }; cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1)); - cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen)); + cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data)); cl_assert_equal_i(pkt->type, GIT_PKT_REF); cl_assert_equal_oid(&pkt->head.oid, &oid); cl_assert_equal_strn(pkt->head.name, expected_ref, strlen(expected_ref)); @@ -171,8 +182,10 @@ static void assert_ref_parses_(const char *line, size_t linelen, const char *exp static void assert_pkt_fails(const char *line) { const char *endptr; + git_pkt_parse_data pkt_parse_data = { 0 }; + git_pkt *pkt; - cl_git_fail(git_pkt_parse_line(&pkt, &endptr, line, strlen(line) + 1)); + cl_git_fail(git_pkt_parse_line(&pkt, &endptr, line, strlen(line) + 1, &pkt_parse_data)); } void test_transports_smart_packet__parsing_garbage_fails(void) From 53fcd5b8f5f069ee9a2567280dca81b74192da74 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 2 Dec 2022 00:45:13 +0000 Subject: [PATCH 15/22] transport: teach transports about oid types and SHA256 --- include/git2/sys/transport.h | 12 ++++ src/libgit2/clone.c | 26 +++++++- src/libgit2/fetch.c | 4 -- src/libgit2/indexer.c | 56 +++++++++++----- src/libgit2/remote.c | 64 +++++++++--------- src/libgit2/remote.h | 32 +++++++++ src/libgit2/streams/socket.c | 4 +- src/libgit2/transports/local.c | 14 ++++ src/libgit2/transports/smart.c | 35 ++++++++++ src/libgit2/transports/smart.h | 4 ++ src/libgit2/transports/smart_pkt.c | 86 +++++++++++++++++-------- src/libgit2/transports/smart_protocol.c | 29 ++++++++- src/util/hash.h | 13 ++++ 13 files changed, 297 insertions(+), 82 deletions(-) diff --git a/include/git2/sys/transport.h b/include/git2/sys/transport.h index 06ae7079f..b70582188 100644 --- a/include/git2/sys/transport.h +++ b/include/git2/sys/transport.h @@ -57,6 +57,18 @@ struct git_transport { unsigned int *capabilities, git_transport *transport); +#ifdef GIT_EXPERIMENTAL_SHA256 + /** + * Gets the object type for the remote repository. + * + * This function may be called after a successful call to + * `connect()`. + */ + int GIT_CALLBACK(oid_type)( + git_oid_t *object_type, + git_transport *transport); +#endif + /** * Get the list of available references in the remote repository. * diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 0d393eb85..886159fbd 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -393,12 +393,19 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c return error; } -static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch) +static int clone_into( + git_repository *repo, + git_remote *_remote, + const git_fetch_options *opts, + const git_checkout_options *co_opts, + const char *branch) { int error; git_str reflog_message = GIT_STR_INIT; + git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; git_fetch_options fetch_opts; git_remote *remote; + git_oid_t oid_type; GIT_ASSERT_ARG(repo); GIT_ASSERT_ARG(_remote); @@ -414,8 +421,25 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch memcpy(&fetch_opts, opts, sizeof(git_fetch_options)); fetch_opts.update_fetchhead = 0; fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL; + + if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0) + return error; + git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote)); + /* + * Connect to the server so that we can identify the remote + * object format. + */ + + if ((error = git_remote_connect_ext(remote, GIT_DIRECTION_FETCH, + &connect_opts)) < 0) + goto cleanup; + + if ((error = git_remote_oid_type(&oid_type, remote)) < 0 || + (error = git_repository__set_objectformat(repo, oid_type)) < 0) + goto cleanup; + if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0) goto cleanup; diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c index 5c2fee617..003b5198a 100644 --- a/src/libgit2/fetch.c +++ b/src/libgit2/fetch.c @@ -95,7 +95,6 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) git_remote_head **heads; git_refspec tagspec, head, *spec; int error = 0; - git_odb *odb; size_t i, heads_len; unsigned int remote_caps; unsigned int oid_mask = GIT_REMOTE_CAPABILITY_TIP_OID | @@ -126,9 +125,6 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts) goto cleanup; } - if ((error = git_repository_odb__weakptr(&odb, remote->repo)) < 0) - goto cleanup; - if ((error = git_remote_ls((const git_remote_head ***)&heads, &heads_len, remote)) < 0 || (error = git_remote_capabilities(&remote_caps, remote)) < 0) goto cleanup; diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c index dfc326e02..fa55fb5ea 100644 --- a/src/libgit2/indexer.c +++ b/src/libgit2/indexer.c @@ -56,8 +56,8 @@ struct git_indexer { git_vector deltas; unsigned int fanout[256]; git_hash_ctx hash_ctx; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; - char name[(GIT_HASH_SHA1_SIZE * 2) + 1]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; + char name[(GIT_HASH_MAX_SIZE * 2) + 1]; git_indexer_progress_cb progress_cb; void *progress_payload; char objbuf[8*1024]; @@ -69,7 +69,7 @@ struct git_indexer { git_odb *odb; /* Fields for calculating the packfile trailer (hash of everything before it) */ - char inbuf[GIT_OID_MAX_SIZE]; + char inbuf[GIT_HASH_MAX_SIZE]; size_t inbuf_len; git_hash_ctx trailer; }; @@ -137,6 +137,20 @@ int git_indexer_init_options(git_indexer_options *opts, unsigned int version) } #endif +GIT_INLINE(git_hash_algorithm_t) indexer_hash_algorithm(git_indexer *idx) +{ + switch (idx->oid_type) { + case GIT_OID_SHA1: + return GIT_HASH_ALGORITHM_SHA1; +#ifdef GIT_EXPERIMENTAL_SHA256 + case GIT_OID_SHA256: + return GIT_HASH_ALGORITHM_SHA256; +#endif + } + + return GIT_HASH_ALGORITHM_NONE; +} + static int indexer_new( git_indexer **out, const char *prefix, @@ -149,6 +163,7 @@ static int indexer_new( git_indexer *idx; git_str path = GIT_STR_INIT, tmp_path = GIT_STR_INIT; static const char suff[] = "/pack"; + git_hash_algorithm_t checksum_type; int error, fd = -1; if (in_opts) @@ -163,8 +178,10 @@ static int indexer_new( idx->mode = mode ? mode : GIT_PACK_FILE_MODE; git_str_init(&idx->entry_data, 0); - if ((error = git_hash_ctx_init(&idx->hash_ctx, GIT_HASH_ALGORITHM_SHA1)) < 0 || - (error = git_hash_ctx_init(&idx->trailer, GIT_HASH_ALGORITHM_SHA1)) < 0 || + checksum_type = indexer_hash_algorithm(idx); + + if ((error = git_hash_ctx_init(&idx->hash_ctx, checksum_type)) < 0 || + (error = git_hash_ctx_init(&idx->trailer, checksum_type)) < 0 || (error = git_oidmap_new(&idx->expected_oids)) < 0) goto cleanup; @@ -182,8 +199,7 @@ static int indexer_new( if (fd < 0) goto cleanup; - /* TODO: SHA256 */ - error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), 0); + error = git_packfile_alloc(&idx->pack, git_str_cstr(&tmp_path), oid_type); git_str_dispose(&tmp_path); if (error < 0) @@ -614,7 +630,7 @@ static int do_progress_callback(git_indexer *idx, git_indexer_progress *stats) return 0; } -/* Hash everything but the last 20B of input */ +/* Hash everything but the checksum trailer */ static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) { size_t to_expell, to_keep; @@ -623,7 +639,10 @@ static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size) if (size == 0) return; - /* Easy case, dump the buffer and the data minus the last 20 bytes */ + /* + * Easy case, dump the buffer and the data minus the trailing + * checksum (SHA1 or SHA256). + */ if (size >= oid_size) { git_hash_update(&idx->trailer, idx->inbuf, idx->inbuf_len); git_hash_update(&idx->trailer, data, size - oid_size); @@ -761,12 +780,14 @@ static int read_stream_object(git_indexer *idx, git_indexer_progress *stats) { git_packfile_stream *stream = &idx->stream; off64_t entry_start = idx->off; - size_t entry_size; + size_t oid_size, entry_size; git_object_t type; git_mwindow *w = NULL; int error; - if (idx->pack->mwf.size <= idx->off + 20) + oid_size = git_oid_size(idx->oid_type); + + if (idx->pack->mwf.size <= idx->off + (long long)oid_size) return GIT_EBUFS; if (!idx->have_stream) { @@ -963,15 +984,17 @@ static int inject_object(git_indexer *idx, git_oid *id) git_odb_object *obj = NULL; struct entry *entry = NULL; struct git_pack_entry *pentry = NULL; - unsigned char empty_checksum[GIT_HASH_SHA1_SIZE] = {0}; + unsigned char empty_checksum[GIT_HASH_MAX_SIZE] = {0}; unsigned char hdr[64]; git_str buf = GIT_STR_INIT; off64_t entry_start; const void *data; size_t len, hdr_len; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + size_t checksum_size; int error; + checksum_size = git_hash_size(indexer_hash_algorithm(idx)); + if ((error = seek_back_trailer(idx)) < 0) goto cleanup; @@ -1205,10 +1228,10 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) struct git_pack_idx_header hdr; git_str filename = GIT_STR_INIT; struct entry *entry; - unsigned char checksum[GIT_HASH_SHA1_SIZE]; + unsigned char checksum[GIT_HASH_MAX_SIZE]; git_filebuf index_file = {0}; void *packfile_trailer; - size_t checksum_size = GIT_HASH_SHA1_SIZE; + size_t checksum_size; bool mismatch; if (!idx->parsed_header) { @@ -1216,6 +1239,9 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats) return -1; } + checksum_size = git_hash_size(indexer_hash_algorithm(idx)); + GIT_ASSERT(checksum_size); + /* Test for this before resolve_deltas(), as it plays with idx->off */ if (idx->off + (ssize_t)checksum_size < idx->pack->mwf.size) { git_error_set(GIT_ERROR_INDEXER, "unexpected data at the end of the pack"); diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c index 02d271d7d..3583ec031 100644 --- a/src/libgit2/remote.c +++ b/src/libgit2/remote.c @@ -1026,6 +1026,24 @@ int git_remote_capabilities(unsigned int *out, git_remote *remote) return remote->transport->capabilities(out, remote->transport); } +int git_remote_oid_type(git_oid_t *out, git_remote *remote) +{ + GIT_ASSERT_ARG(remote); + + if (!remote->transport) { + git_error_set(GIT_ERROR_NET, "this remote has never connected"); + *out = 0; + return -1; + } + +#ifdef GIT_EXPERIMENTAL_SHA256 + return remote->transport->oid_type(out, remote->transport); +#else + *out = GIT_OID_SHA1; + return 0; +#endif +} + static int lookup_config(char **out, git_config *cfg, const char *name) { git_config_entry *ce = NULL; @@ -1225,24 +1243,6 @@ static int ls_to_vector(git_vector *out, git_remote *remote) return 0; } -#define copy_opts(out, in) \ - if (in) { \ - (out)->callbacks = (in)->callbacks; \ - (out)->proxy_opts = (in)->proxy_opts; \ - (out)->custom_headers = (in)->custom_headers; \ - (out)->follow_redirects = (in)->follow_redirects; \ - } - -GIT_INLINE(int) connect_opts_from_fetch_opts( - git_remote_connect_options *out, - git_remote *remote, - const git_fetch_options *fetch_opts) -{ - git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; - copy_opts(&tmp, fetch_opts); - return git_remote_connect_options_normalize(out, remote->repo, &tmp); -} - static int connect_or_reset_options( git_remote *remote, int direction, @@ -1330,7 +1330,8 @@ int git_remote_download( return -1; } - if (connect_opts_from_fetch_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_fetch_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0) @@ -1350,6 +1351,8 @@ int git_remote_fetch( bool prune = false; git_str reflog_msg_buf = GIT_STR_INIT; git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT; + unsigned int capabilities; + git_oid_t oid_type; GIT_ASSERT_ARG(remote); @@ -1358,7 +1361,8 @@ int git_remote_fetch( return -1; } - if (connect_opts_from_fetch_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_fetch_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0) @@ -1369,6 +1373,10 @@ int git_remote_fetch( tagopt = opts->download_tags; } + if ((error = git_remote_capabilities(&capabilities, remote)) < 0 || + (error = git_remote_oid_type(&oid_type, remote)) < 0) + return error; + /* Connect and download everything */ error = git_remote__download(remote, refspecs, opts); @@ -2896,16 +2904,6 @@ done: return error; } -GIT_INLINE(int) connect_opts_from_push_opts( - git_remote_connect_options *out, - git_remote *remote, - const git_push_options *push_opts) -{ - git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; - copy_opts(&tmp, push_opts); - return git_remote_connect_options_normalize(out, remote->repo, &tmp); -} - int git_remote_upload( git_remote *remote, const git_strarray *refspecs, @@ -2924,7 +2922,8 @@ int git_remote_upload( return -1; } - if ((error = connect_opts_from_push_opts(&connect_opts, remote, opts)) < 0) + if ((error = git_remote_connect_options__from_push_opts( + &connect_opts, remote, opts)) < 0) goto cleanup; if ((error = connect_or_reset_options(remote, GIT_DIRECTION_PUSH, &connect_opts)) < 0) @@ -2985,7 +2984,8 @@ int git_remote_push( return -1; } - if (connect_opts_from_push_opts(&connect_opts, remote, opts) < 0) + if (git_remote_connect_options__from_push_opts(&connect_opts, + remote, opts) < 0) return -1; if ((error = git_remote_upload(remote, refspecs, opts)) < 0) diff --git a/src/libgit2/remote.h b/src/libgit2/remote.h index 41ee58e0f..87dab4eba 100644 --- a/src/libgit2/remote.h +++ b/src/libgit2/remote.h @@ -56,5 +56,37 @@ int git_remote_connect_options_normalize( const git_remote_connect_options *src); int git_remote_capabilities(unsigned int *out, git_remote *remote); +int git_remote_oid_type(git_oid_t *out, git_remote *remote); + + +#define git_remote_connect_options__copy_opts(out, in) \ + if (in) { \ + (out)->callbacks = (in)->callbacks; \ + (out)->proxy_opts = (in)->proxy_opts; \ + (out)->custom_headers = (in)->custom_headers; \ + (out)->follow_redirects = (in)->follow_redirects; \ + } + +GIT_INLINE(int) git_remote_connect_options__from_fetch_opts( + git_remote_connect_options *out, + git_remote *remote, + const git_fetch_options *fetch_opts) +{ + git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; + git_remote_connect_options__copy_opts(&tmp, fetch_opts); + return git_remote_connect_options_normalize(out, remote->repo, &tmp); +} + +GIT_INLINE(int) git_remote_connect_options__from_push_opts( + git_remote_connect_options *out, + git_remote *remote, + const git_push_options *push_opts) +{ + git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT; + git_remote_connect_options__copy_opts(&tmp, push_opts); + return git_remote_connect_options_normalize(out, remote->repo, &tmp); +} + +#undef git_remote_connect_options__copy_opts #endif diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c index 9415fe892..cbf805879 100644 --- a/src/libgit2/streams/socket.c +++ b/src/libgit2/streams/socket.c @@ -135,9 +135,11 @@ static ssize_t socket_write(git_stream *stream, const char *data, size_t len, in git_socket_stream *st = (git_socket_stream *) stream; ssize_t written; + assert(flags == 0); + errno = 0; - if ((written = p_send(st->s, data, len, flags)) < 0) { + if ((written = p_send(st->s, data, len, 0)) < 0) { net_set_error("error sending data"); return -1; } diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c index 6c754a034..4d86f1713 100644 --- a/src/libgit2/transports/local.c +++ b/src/libgit2/transports/local.c @@ -266,6 +266,17 @@ static int local_capabilities(unsigned int *capabilities, git_transport *transpo return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +static int local_oid_type(git_oid_t *out, git_transport *transport) +{ + transport_local *t = (transport_local *)transport; + + *out = t->repo->oid_type; + + return 0; +} +#endif + static int local_ls(const git_remote_head ***out, size_t *size, git_transport *transport) { transport_local *t = (transport_local *)transport; @@ -732,6 +743,9 @@ int git_transport_local(git_transport **out, git_remote *owner, void *param) t->parent.connect = local_connect; t->parent.set_connect_opts = local_set_connect_opts; t->parent.capabilities = local_capabilities; +#ifdef GIT_EXPERIMENTAL_SHA256 + t->parent.oid_type = local_oid_type; +#endif t->parent.negotiate_fetch = local_negotiate_fetch; t->parent.download_pack = local_download_pack; t->parent.push = local_push; diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c index 7f57dba2a..c3a764bd3 100644 --- a/src/libgit2/transports/smart.c +++ b/src/libgit2/transports/smart.c @@ -54,6 +54,12 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp return -1; } + git__free(t->caps.object_format); + t->caps.object_format = NULL; + + git__free(t->caps.agent); + t->caps.agent = NULL; + return 0; } @@ -242,6 +248,30 @@ static int git_smart__capabilities(unsigned int *capabilities, git_transport *tr return 0; } +#ifdef GIT_EXPERIMENTAL_SHA256 +static int git_smart__oid_type(git_oid_t *out, git_transport *transport) +{ + transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent); + + *out = 0; + + if (t->caps.object_format == NULL) { + *out = GIT_OID_DEFAULT; + } else { + *out = git_oid_type_fromstr(t->caps.object_format); + + if (!*out) { + git_error_set(GIT_ERROR_INVALID, + "unknown object format '%s'", + t->caps.object_format); + return -1; + } + } + + return 0; +} +#endif + static int git_smart__ls(const git_remote_head ***out, size_t *size, git_transport *transport) { transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent); @@ -386,6 +416,8 @@ static void git_smart__free(git_transport *transport) git_remote_connect_options_dispose(&t->connect_opts); + git__free(t->caps.object_format); + git__free(t->caps.agent); git__free(t); } @@ -452,6 +484,9 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param) t->parent.connect = git_smart__connect; t->parent.set_connect_opts = git_smart__set_connect_opts; t->parent.capabilities = git_smart__capabilities; +#ifdef GIT_EXPERIMENTAL_SHA256 + t->parent.oid_type = git_smart__oid_type; +#endif t->parent.close = git_smart__close; t->parent.free = git_smart__free; t->parent.negotiate_fetch = git_smart__negotiate_fetch; diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h index ca6496163..d71160d8e 100644 --- a/src/libgit2/transports/smart.h +++ b/src/libgit2/transports/smart.h @@ -32,6 +32,8 @@ #define GIT_CAP_SYMREF "symref" #define GIT_CAP_WANT_TIP_SHA1 "allow-tip-sha1-in-want" #define GIT_CAP_WANT_REACHABLE_SHA1 "allow-reachable-sha1-in-want" +#define GIT_CAP_OBJECT_FORMAT "object-format=" +#define GIT_CAP_AGENT "agent=" extern bool git_smart__ofs_delta_enabled; @@ -133,6 +135,8 @@ typedef struct transport_smart_caps { thin_pack:1, want_tip_sha1:1, want_reachable_sha1:1; + char *object_format; + char *agent; } transport_smart_caps; typedef int (*packetsize_cb)(size_t received, void *payload); diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c index b6428d845..5fce42175 100644 --- a/src/libgit2/transports/smart_pkt.c +++ b/src/libgit2/transports/smart_pkt.c @@ -21,11 +21,14 @@ #include -#define PKT_LEN_SIZE 4 -static const char pkt_done_str[] = "0009done\n"; -static const char pkt_flush_str[] = "0000"; -static const char pkt_have_prefix[] = "0032have "; -static const char pkt_want_prefix[] = "0032want "; +#define PKT_DONE_STR "0009done\n" +#define PKT_FLUSH_STR "0000" +#define PKT_HAVE_PREFIX "have " +#define PKT_WANT_PREFIX "want " + +#define PKT_LEN_SIZE 4 +#define PKT_MAX_SIZE 0xffff +#define PKT_MAX_WANTLEN (PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + GIT_OID_MAX_HEXSIZE + 1) static int flush_pkt(git_pkt **out) { @@ -598,16 +601,20 @@ void git_pkt_free(git_pkt *pkt) int git_pkt_buffer_flush(git_str *buf) { - return git_str_put(buf, pkt_flush_str, strlen(pkt_flush_str)); + return git_str_put(buf, PKT_FLUSH_STR, CONST_STRLEN(PKT_FLUSH_STR)); } -static int buffer_want_with_caps(const git_remote_head *head, transport_smart_caps *caps, git_str *buf) +static int buffer_want_with_caps( + const git_remote_head *head, + transport_smart_caps *caps, + git_oid_t oid_type, + git_str *buf) { git_str str = GIT_STR_INIT; - char oid[GIT_OID_MAX_HEXSIZE + 1] = {0}; + char oid[GIT_OID_MAX_HEXSIZE]; size_t oid_hexsize, len; - oid_hexsize = git_oid_hexsize(head->oid.type); + oid_hexsize = git_oid_hexsize(oid_type); git_oid_fmt(oid, &head->oid); /* Prefer multi_ack_detailed */ @@ -634,18 +641,19 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca if (git_str_oom(&str)) return -1; - len = strlen("XXXXwant ") + oid_hexsize + 1 /* NUL */ + - git_str_len(&str) + 1 /* LF */; - - if (len > 0xffff) { + if (str.size > (PKT_MAX_SIZE - (PKT_MAX_WANTLEN + 1))) { git_error_set(GIT_ERROR_NET, - "tried to produce packet with invalid length %" PRIuZ, len); + "tried to produce packet with invalid caps length %" PRIuZ, str.size); return -1; } + len = PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + + oid_hexsize + 1 /* NUL */ + + git_str_len(&str) + 1 /* LF */; + git_str_grow_by(buf, len); git_str_printf(buf, - "%04xwant %.*s %s\n", (unsigned int)len, + "%04x%s%.*s %s\n", (unsigned int)len, PKT_WANT_PREFIX, (int)oid_hexsize, oid, git_str_cstr(&str)); git_str_dispose(&str); @@ -665,8 +673,21 @@ int git_pkt_buffer_wants( transport_smart_caps *caps, git_str *buf) { - size_t i = 0; const git_remote_head *head; + char oid[GIT_OID_MAX_HEXSIZE]; + git_oid_t oid_type; + size_t oid_hexsize, want_len, i = 0; + +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = count > 0 ? refs[0]->oid.type : GIT_OID_SHA1; +#else + oid_type = GIT_OID_SHA1; +#endif + + oid_hexsize = git_oid_hexsize(oid_type); + + want_len = PKT_LEN_SIZE + CONST_STRLEN(PKT_WANT_PREFIX) + + oid_hexsize + 1 /* LF */; if (caps->common) { for (; i < count; ++i) { @@ -675,15 +696,13 @@ int git_pkt_buffer_wants( break; } - if (buffer_want_with_caps(refs[i], caps, buf) < 0) + if (buffer_want_with_caps(refs[i], caps, oid_type, buf) < 0) return -1; i++; } for (; i < count; ++i) { - char oid[GIT_OID_MAX_HEXSIZE]; - head = refs[i]; if (head->local) @@ -691,9 +710,9 @@ int git_pkt_buffer_wants( git_oid_fmt(oid, &head->oid); - git_str_put(buf, pkt_want_prefix, strlen(pkt_want_prefix)); - git_str_put(buf, oid, git_oid_hexsize(head->oid.type)); - git_str_putc(buf, '\n'); + git_str_printf(buf, "%04x%s%.*s\n", + (unsigned int)want_len, PKT_WANT_PREFIX, + (int)oid_hexsize, oid); if (git_str_oom(buf)) return -1; @@ -704,14 +723,27 @@ int git_pkt_buffer_wants( int git_pkt_buffer_have(git_oid *oid, git_str *buf) { - char oidhex[GIT_OID_SHA1_HEXSIZE + 1]; + char oid_str[GIT_OID_MAX_HEXSIZE]; + git_oid_t oid_type; + size_t oid_hexsize, have_len; - memset(oidhex, 0x0, sizeof(oidhex)); - git_oid_fmt(oidhex, oid); - return git_str_printf(buf, "%s%s\n", pkt_have_prefix, oidhex); +#ifdef GIT_EXPERIMENTAL_SHA256 + oid_type = oid->type; +#else + oid_type = GIT_OID_SHA1; +#endif + + oid_hexsize = git_oid_hexsize(oid_type); + have_len = PKT_LEN_SIZE + CONST_STRLEN(PKT_HAVE_PREFIX) + + oid_hexsize + 1 /* LF */; + + git_oid_fmt(oid_str, oid); + return git_str_printf(buf, "%04x%s%.*s\n", + (unsigned int)have_len, PKT_HAVE_PREFIX, + (int)oid_hexsize, oid_str); } int git_pkt_buffer_done(git_str *buf) { - return git_str_puts(buf, pkt_done_str); + return git_str_put(buf, PKT_DONE_STR, CONST_STRLEN(PKT_DONE_STR)); } diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c index 86d02df83..0d47acafe 100644 --- a/src/libgit2/transports/smart_protocol.c +++ b/src/libgit2/transports/smart_protocol.c @@ -134,9 +134,12 @@ on_invalid: return -1; } -int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs) +int git_smart__detect_caps( + git_pkt_ref *pkt, + transport_smart_caps *caps, + git_vector *symrefs) { - const char *ptr; + const char *ptr, *start; /* No refs or capabilities, odd but not a problem */ if (pkt == NULL || pkt->capabilities == NULL) @@ -218,6 +221,28 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec continue; } + if (!git__prefixcmp(ptr, GIT_CAP_OBJECT_FORMAT)) { + ptr += strlen(GIT_CAP_OBJECT_FORMAT); + + start = ptr; + ptr = strchr(ptr, ' '); + + if ((caps->object_format = git__strndup(start, (ptr - start))) == NULL) + return -1; + continue; + } + + if (!git__prefixcmp(ptr, GIT_CAP_AGENT)) { + ptr += strlen(GIT_CAP_AGENT); + + start = ptr; + ptr = strchr(ptr, ' '); + + if ((caps->agent = git__strndup(start, (ptr - start))) == NULL) + return -1; + continue; + } + /* We don't know this capability, so skip it */ ptr = strchr(ptr, ' '); } diff --git a/src/util/hash.h b/src/util/hash.h index 387c5a66f..21fcaf045 100644 --- a/src/util/hash.h +++ b/src/util/hash.h @@ -23,6 +23,8 @@ typedef enum { GIT_HASH_ALGORITHM_SHA256 } git_hash_algorithm_t; +#define GIT_HASH_MAX_SIZE GIT_HASH_SHA256_SIZE + typedef struct git_hash_ctx { union { git_hash_sha1_ctx sha1; @@ -45,4 +47,15 @@ int git_hash_vec(unsigned char *out, git_str_vec *vec, size_t n, git_hash_algori int git_hash_fmt(char *out, unsigned char *hash, size_t hash_len); +GIT_INLINE(size_t) git_hash_size(git_hash_algorithm_t algorithm) { + switch (algorithm) { + case GIT_HASH_ALGORITHM_SHA1: + return GIT_HASH_SHA1_SIZE; + case GIT_HASH_ALGORITHM_SHA256: + return GIT_HASH_SHA256_SIZE; + default: + return 0; + } +} + #endif From af20d13b18dbab4de9f244402c255bc85e907ac1 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Sun, 4 Dec 2022 14:22:02 +0000 Subject: [PATCH 16/22] repo: dump backends on oid type change --- src/libgit2/repository.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 2da6caf3a..928f4635c 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1674,6 +1674,12 @@ int git_repository__set_objectformat( if (oid_type == GIT_OID_DEFAULT) return 0; + if (!git_repository_is_empty(repo) && repo->oid_type != oid_type) { + git_error_set(GIT_ERROR_REPOSITORY, + "cannot change object id type of existing repository"); + return -1; + } + if (git_repository_config__weakptr(&cfg, repo) < 0) return -1; @@ -1683,7 +1689,18 @@ int git_repository__set_objectformat( git_oid_type_name(oid_type)) < 0) return -1; - repo->oid_type = oid_type; + /* + * During repo init, we may create some backends with the + * default oid type. Clear them so that we create them with + * the proper oid type. + */ + if (repo->oid_type != oid_type) { + set_index(repo, NULL); + set_odb(repo, NULL); + set_refdb(repo, NULL); + + repo->oid_type = oid_type; + } return 0; } From 8eadeedee46e8cd4ac2364134b4696b1473d17dc Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Thu, 9 Feb 2023 17:14:01 +0000 Subject: [PATCH 17/22] repo: take an oid_type when initializing --- include/git2/repository.h | 9 +++++++++ src/libgit2/repository.c | 18 +++++++++++++++--- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/include/git2/repository.h b/include/git2/repository.h index 9b56599d7..04c240d24 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -351,6 +351,15 @@ typedef struct { * pointing to this URL. */ const char *origin_url; + +#ifdef GIT_EXPERIMENTAL_SHA256 + /** + * + * Type of object IDs to use for this repository, or 0 for + * default (currently SHA1). + */ + git_oid_t oid_type; +#endif } git_repository_init_options; #define GIT_REPOSITORY_INIT_OPTIONS_VERSION 1 diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c index 928f4635c..489d627a0 100644 --- a/src/libgit2/repository.c +++ b/src/libgit2/repository.c @@ -1983,7 +1983,8 @@ static int repo_init_config( const char *repo_dir, const char *work_dir, uint32_t flags, - uint32_t mode) + uint32_t mode, + git_oid_t oid_type) { int error = 0; git_str cfg_path = GIT_STR_INIT, worktree_path = GIT_STR_INIT; @@ -2040,6 +2041,11 @@ static int repo_init_config( SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true); } + if (oid_type != GIT_OID_SHA1) { + SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1); + SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type)); + } + cleanup: git_str_dispose(&cfg_path); git_str_dispose(&worktree_path); @@ -2520,6 +2526,7 @@ int git_repository_init_ext( common_path = GIT_STR_INIT; const char *wd; bool is_valid; + git_oid_t oid_type = GIT_OID_DEFAULT; int error; GIT_ASSERT_ARG(out); @@ -2528,6 +2535,11 @@ int git_repository_init_ext( GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options"); +#ifdef GIT_EXPERIMENTAL_SHA256 + if (opts->oid_type) + oid_type = opts->oid_type; +#endif + if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0) goto out; @@ -2546,13 +2558,13 @@ int git_repository_init_ext( opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT; - if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0) + if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0) goto out; /* TODO: reinitialize the templates */ } else { if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 || - (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 || + (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0 || (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0) goto out; } From 6cb7966d5a9b8d704e7a221c1fd8e8c0aba02b7b Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 09:46:33 +0000 Subject: [PATCH 18/22] clone: free connect opts --- src/libgit2/clone.c | 1 + src/libgit2/remote.h | 8 ++++++++ 2 files changed, 9 insertions(+) diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c index 886159fbd..e8885f22a 100644 --- a/src/libgit2/clone.c +++ b/src/libgit2/clone.c @@ -447,6 +447,7 @@ static int clone_into( cleanup: git_remote_free(remote); + git_remote_connect_options_dispose(&connect_opts); git_str_dispose(&reflog_message); return error; diff --git a/src/libgit2/remote.h b/src/libgit2/remote.h index 87dab4eba..676b3c2ab 100644 --- a/src/libgit2/remote.h +++ b/src/libgit2/remote.h @@ -17,6 +17,7 @@ #include "refspec.h" #include "vector.h" #include "net.h" +#include "proxy.h" #define GIT_REMOTE_ORIGIN "origin" @@ -89,4 +90,11 @@ GIT_INLINE(int) git_remote_connect_options__from_push_opts( #undef git_remote_connect_options__copy_opts +GIT_INLINE(void) git_remote_connect_options__dispose( + git_remote_connect_options *opts) +{ + git_proxy_options_dispose(&opts->proxy_opts); + git_strarray_dispose(&opts->custom_headers); +} + #endif From f72707872b036f1283537b248f0199ac193c6933 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 10:56:18 +0000 Subject: [PATCH 19/22] ci: actually build sha256 support on linux --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 39cefdb19..767eb121a 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -226,7 +226,7 @@ jobs: env: CC: clang CMAKE_GENERATOR: Ninja - CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON + CMAKE_OPTIONS: -DUSE_HTTPS=OpenSSL -DDEPRECATE_HARD=ON -DUSE_LEAK_CHECKER=valgrind -DUSE_GSSAPI=ON -DUSE_SSH=ON -DEXPERIMENTAL_SHA256=ON os: ubuntu-latest - name: "macOS (SHA256)" id: macos From d63f1fe2457edbcdae7e20f1c1e4b75fbff8354e Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 11:08:34 +0000 Subject: [PATCH 20/22] cmake: support older cmakes --- cmake/ExperimentalFeatures.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/ExperimentalFeatures.cmake b/cmake/ExperimentalFeatures.cmake index 57a66e68d..7eff40bdb 100644 --- a/cmake/ExperimentalFeatures.cmake +++ b/cmake/ExperimentalFeatures.cmake @@ -13,7 +13,7 @@ if(EXPERIMENTAL_SHA256) set(EXPERIMENTAL 1) set(GIT_EXPERIMENTAL_SHA256 1) - add_compile_definitions(GIT_EXPERIMENTAL_SHA256) + add_definitions(-DGIT_EXPERIMENTAL_SHA256=1) else() add_feature_info("SHA256 API" OFF "experimental SHA256 APIs") endif() From e7a7691146f3ce1b85e3f79be4fe40745973ffe9 Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 14:16:08 +0000 Subject: [PATCH 21/22] win32: adjust max path length for SHA256 The longest path within a git repository is now a SHA256 format packfile. Adjust our max length checking to match. --- tests/libgit2/repo/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c index 637d4a903..d78ec063c 100644 --- a/tests/libgit2/repo/init.c +++ b/tests/libgit2/repo/init.c @@ -727,7 +727,7 @@ void test_repo_init__defaultbranch_config_empty(void) void test_repo_init__longpath(void) { #ifdef GIT_WIN32 - size_t padding = CONST_STRLEN("objects/pack/pack-.pack.lock") + GIT_OID_SHA1_HEXSIZE; + size_t padding = CONST_STRLEN("objects/pack/pack-.pack.lock") + GIT_OID_MAX_HEXSIZE; size_t max, i; git_str path = GIT_STR_INIT; git_repository *one = NULL, *two = NULL; From e3cd859150f720914dfbbdd2d80d12b1482a397a Mon Sep 17 00:00:00 2001 From: Edward Thomson Date: Fri, 10 Feb 2023 15:14:36 +0000 Subject: [PATCH 22/22] ci: build our own git on xenial The git included with xenial is ancient, and lacks sha256 support. --- ci/docker/xenial | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/ci/docker/xenial b/ci/docker/xenial index f5fa5a315..578f0a962 100644 --- a/ci/docker/xenial +++ b/ci/docker/xenial @@ -7,11 +7,13 @@ RUN apt-get update && \ clang \ cmake \ curl \ + gettext \ gcc \ - git \ krb5-user \ libcurl4-gnutls-dev \ + libexpat1-dev \ libgcrypt20-dev \ + libintl-perl \ libkrb5-dev \ libpcre3-dev \ libssl-dev \ @@ -28,7 +30,17 @@ RUN apt-get update && \ && \ rm -rf /var/lib/apt/lists/* -FROM apt AS mbedtls +FROM apt AS git +RUN cd /tmp && \ + curl --location --silent --show-error https://github.com/git/git/archive/refs/tags/v2.39.1.tar.gz | \ + tar -xz && \ + cd git-2.39.1 && \ + make && \ + make prefix=/usr install && \ + cd .. && \ + rm -rf git-2.39.1 + +FROM git AS mbedtls RUN cd /tmp && \ curl --location --silent --show-error https://github.com/Mbed-TLS/mbedtls/archive/refs/tags/mbedtls-2.16.2.tar.gz | \ tar -xz && \