[PATCH v7 00/13] nd/pack-objects-pack-struct updates
- From
Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
- Date
- Mar 24, 2018, 06:33 UTC
- Message-ID
- <20180324063353.24722-1-pclouds@gmail.com>
- In-Reply-To
- <20180318142526.9378-1-pclouds@gmail.com>
Phew.. pack-objects is tough to crack. v7 changes
- the 16k pack limit is removed thanks to Jeff suggestion. The limit for memory saving though is reduced down to 1k again. - only object size below 2G is cached (previously 4G) to avoid 1 << 32 on 32 bits. - fix oe_size() retrieving wrong size (e.g. if entry->type is a delta then it must return delta size not canonical size) - fix race condition when oe_size() (and oe_delta_size()) accesses object database in parallel try_delta code. - add new GIT_TEST_ vars so that we use the whole test suite to exercise these hard-to-activate code paths. - I finally fixed the "compressed" typo!
I'm not ignoring or forgetting other suggestions in this thread. the rev-list thing is still on my todo list (either do it externally or free up mem as Jeff suggested). revindex as well. But those can be done later.
Interdiff
diff --git a/Documentation/git-pack-objects.txt b/Documentation/git-pack-objects.txt index b8d936ccf5..3503c9e3e6 100644 --- a/Documentation/git-pack-objects.txt +++ b/Documentation/git-pack-objects.txt @@ -269,15 +269,6 @@ Unexpected missing object will raise an error. locally created objects [without .promisor] and objects from the promisor remote [with .promisor].) This is used with partial clone. -LIMITATIONS ------------ - -This command could only handle 16384 existing pack files at a time. -If you have more than this, you need to exclude some pack files with -".keep" file and --honor-pack-keep option, to combine 16k pack files -in one, then remove these .keep files and run pack-objects one more -time. - SEE ALSO -------- linkgit:git-rev-list[1] diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c index 4406af640f..c774821930 100644 --- a/builtin/pack-objects.c +++ b/builtin/pack-objects.c @@ -30,6 +30,8 @@ #include "packfile.h" #define IN_PACK(obj) oe_in_pack(&to_pack, obj) +#define SIZE(obj) oe_size(&to_pack, obj) +#define SET_SIZE(obj,size) oe_set_size(&to_pack, obj, size) #define DELTA_SIZE(obj) oe_delta_size(&to_pack, obj) #define DELTA(obj) oe_delta(&to_pack, obj) #define DELTA_CHILD(obj) oe_delta_child(&to_pack, obj) @@ -276,7 +278,7 @@ static unsigned long write_no_reuse_object(struct hashfile *f, struct object_ent if (!usable_delta) { if (oe_type(entry) == OBJ_BLOB && - oe_size_greater_than(entry, big_file_threshold) && + oe_size_greater_than(&to_pack, entry, big_file_threshold) && (st = open_istream(entry->idx.oid.hash, &type, &size, NULL)) != NULL) buf = NULL; else { @@ -386,7 +388,7 @@ static off_t write_reuse_object(struct hashfile *f, struct object_entry *entry, unsigned char header[MAX_PACK_OBJECT_HEADER], dheader[MAX_PACK_OBJECT_HEADER]; unsigned hdrlen; - unsigned long entry_size = oe_size(entry); + unsigned long entry_size = SIZE(entry); if (DELTA(entry)) type = (allow_ofs_delta && DELTA(entry)->idx.offset) ? @@ -1036,7 +1038,7 @@ static int want_object_in_pack(const struct object_id *oid, if (*found_pack) { want = want_found_object(exclude, *found_pack); if (want != -1) - goto done; + return want; } list_for_each(pos, &packed_git_mru) { @@ -1059,16 +1061,11 @@ static int want_object_in_pack(const struct object_id *oid, if (!exclude && want > 0) list_move(&p->mru, &packed_git_mru); if (want != -1) - goto done; + return want; } } - want = 1; -done: - if (want && *found_pack && !(*found_pack)->index) - oe_add_pack(&to_pack, *found_pack); - - return want; + return 1; } static void create_object_entry(const struct object_id *oid, @@ -1090,7 +1087,7 @@ static void create_object_entry(const struct object_id *oid, else nr_result++; if (found_pack) { - oe_set_in_pack(entry, found_pack); + oe_set_in_pack(&to_pack, entry, found_pack); entry->in_pack_offset = found_offset; } @@ -1415,7 +1412,7 @@ static void cleanup_preferred_base(void) static void check_object(struct object_entry *entry) { - unsigned long size; + unsigned long canonical_size; if (IN_PACK(entry)) { struct packed_git *p = IN_PACK(entry); @@ -1427,6 +1424,7 @@ static void check_object(struct object_entry *entry) off_t ofs; unsigned char *buf, c; enum object_type type; + unsigned long in_pack_size; buf = use_pack(p, &w_curs, entry->in_pack_offset, &avail); @@ -1436,14 +1434,13 @@ static void check_object(struct object_entry *entry) */ used = unpack_object_header_buffer(buf, avail, &type, - &size); + &in_pack_size); if (used == 0) goto give_up; if (type < 0) die("BUG: invalid type %d", type); entry->in_pack_type = type; - oe_set_size(entry, size); /* * Determine if this is a delta and if so whether we can @@ -1454,6 +1451,7 @@ static void check_object(struct object_entry *entry) default: /* Not a delta hence we've already got all we need. */ oe_set_type(entry, entry->in_pack_type); + SET_SIZE(entry, in_pack_size); entry->in_pack_header_size = used; if (oe_type(entry) < OBJ_COMMIT || oe_type(entry) > OBJ_BLOB) goto give_up; @@ -1510,8 +1508,9 @@ static void check_object(struct object_entry *entry) * circular deltas. */ oe_set_type(entry, entry->in_pack_type); + SET_SIZE(entry, in_pack_size); /* delta size */ SET_DELTA(entry, base_entry); - SET_DELTA_SIZE(entry, oe_size(entry)); + SET_DELTA_SIZE(entry, in_pack_size); entry->delta_sibling_idx = base_entry->delta_child_idx; SET_DELTA_CHILD(base_entry, entry); unuse_pack(&w_curs); @@ -1519,18 +1518,18 @@ static void check_object(struct object_entry *entry) } if (oe_type(entry)) { - unsigned long size; + off_t delta_pos; - size = get_size_from_delta(p, &w_curs, - entry->in_pack_offset + entry->in_pack_header_size); /* * This must be a delta and we already know what the * final object type is. Let's extract the actual * object size from the delta header. */ - oe_set_size(entry, size); - if (oe_size_less_than(entry, 1)) + delta_pos = entry->in_pack_offset + entry->in_pack_header_size; + canonical_size = get_size_from_delta(p, &w_curs, delta_pos); + if (canonical_size == 0) goto give_up; + SET_SIZE(entry, canonical_size); unuse_pack(&w_curs); return; } @@ -1544,15 +1543,18 @@ static void check_object(struct object_entry *entry) unuse_pack(&w_curs); } - oe_set_type(entry, sha1_object_info(entry->idx.oid.hash, &size)); - /* - * The error condition is checked in prepare_pack(). This is - * to permit a missing preferred base object to be ignored - * as a preferred base. Doing so can result in a larger - * pack file, but the transfer will still take place. - */ - if (entry->type_valid) - oe_set_size(entry, size); + oe_set_type(entry, sha1_object_info(entry->idx.oid.hash, + &canonical_size)); + if (entry->type_valid) { + SET_SIZE(entry, canonical_size); + } else { + /* + * Bad object type is checked in prepare_pack(). This is + * to permit a missing preferred base object to be ignored + * as a preferred base. Doing so can result in a larger + * pack file, but the transfer will still take place. + */ + } } static int pack_offset_sort(const void *_a, const void *_b) @@ -1619,7 +1621,7 @@ static void drop_reused_delta(struct object_entry *entry) } else { oe_set_type(entry, type); } - oe_set_size(entry, size); + SET_SIZE(entry, size); } /* @@ -1759,7 +1761,8 @@ static void get_object_details(void) for (i = 0; i < to_pack.nr_objects; i++) { struct object_entry *entry = sorted_by_offset[i]; check_object(entry); - if (oe_size_greater_than(entry, big_file_threshold)) + if (entry->type_valid && + oe_size_greater_than(&to_pack, entry, big_file_threshold)) entry->no_try_delta = 1; } @@ -1788,8 +1791,8 @@ static int type_size_sort(const void *_a, const void *_b) const struct object_entry *b = *(struct object_entry **)_b; enum object_type a_type = oe_type(a); enum object_type b_type = oe_type(b); - unsigned long a_size = oe_size(a); - unsigned long b_size = oe_size(b); + unsigned long a_size = SIZE(a); + unsigned long b_size = SIZE(b); if (a_type > b_type) return -1; @@ -1858,6 +1861,41 @@ static pthread_mutex_t progress_mutex; #endif +unsigned long oe_get_size_slow(struct packing_data *pack, + const struct object_entry *e) +{ + struct packed_git *p; + struct pack_window *w_curs; + unsigned char *buf; + enum object_type type; + unsigned long used, avail, size; + + if (e->type_ != OBJ_OFS_DELTA && e->type_ != OBJ_REF_DELTA) { + read_lock(); + if (sha1_object_info(e->idx.oid.hash, &size) < 0) + die(_("unable to get size of %s"), + oid_to_hex(&e->idx.oid)); + read_unlock(); + return size; + } + + p = oe_in_pack(pack, e); + if (!p) + die("BUG: when e->type is a delta, it must belong to a pack"); + + read_lock(); + w_curs = NULL; + buf = use_pack(p, &w_curs, e->in_pack_offset, &avail); + used = unpack_object_header_buffer(buf, avail, &type, &size); + if (used == 0) + die(_("unable to parse object header of %s"), + oid_to_hex(&e->idx.oid)); + + unuse_pack(&w_curs); + read_unlock(); + return size; +} + static int try_delta(struct unpacked *trg, struct unpacked *src, unsigned max_depth, unsigned long *mem_usage) { @@ -1892,7 +1930,7 @@ static int try_delta(struct unpacked *trg, struct unpacked *src, return 0; /* Now some size filtering heuristics. */ - trg_size = oe_size(trg_entry); + trg_size = SIZE(trg_entry); if (!DELTA(trg_entry)) { max_size = trg_size/2 - 20; ref_depth = 1; @@ -1904,7 +1942,7 @@ static int try_delta(struct unpacked *trg, struct unpacked *src, (max_depth - ref_depth + 1); if (max_size == 0) return 0; - src_size = oe_size(src_entry); + src_size = SIZE(src_entry); sizediff = src_size < trg_size ? trg_size - src_size : 0; if (sizediff >= max_size) return 0; @@ -2026,7 +2064,7 @@ static unsigned long free_unpacked(struct unpacked *n) free_delta_index(n->index); n->index = NULL; if (n->data) { - freed_mem += oe_size(n->entry); + freed_mem += SIZE(n->entry); FREE_AND_NULL(n->data); } n->entry = NULL; @@ -2476,7 +2514,8 @@ static void prepare_pack(int window, int depth) */ continue; - if (oe_size_less_than(entry, 50)) + if (!entry->type_valid || + oe_size_less_than(&to_pack, entry, 50)) continue; if (entry->no_try_delta) @@ -3235,9 +3274,6 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix) } } - /* make sure IN_PACK(0) return NULL */ - oe_add_pack(&to_pack, NULL); - if (progress) progress_state = start_progress(_("Counting objects"), 0); if (!use_internal_rev_list) diff --git a/pack-objects.c b/pack-objects.c index 9558d13834..59c6e40a02 100644 --- a/pack-objects.c +++ b/pack-objects.c @@ -2,6 +2,7 @@ #include "object.h" #include "pack.h" #include "pack-objects.h" +#include "packfile.h" static uint32_t locate_object_entry_hash(struct packing_data *pdata, const unsigned char *sha1, @@ -86,15 +87,54 @@ struct object_entry *packlist_find(struct packing_data *pdata, return &pdata->objects[pdata->index[i] - 1]; } +static void prepare_in_pack_by_idx(struct packing_data *pdata) +{ + struct packed_git **mapping, *p; + int cnt = 0, nr = 1 << OE_IN_PACK_BITS; + + if (getenv("GIT_TEST_FULL_IN_PACK_ARRAY")) { + /* + * leave in_pack_by_idx NULL to force in_pack[] to be + * used instead + */ + return; + } + + ALLOC_ARRAY(mapping, nr); + mapping[cnt++] = NULL; /* zero index must be mapped to NULL */ + prepare_packed_git(); + for (p = packed_git; p; p = p->next, cnt++) { + if (cnt == nr) { + free(mapping); + return; + } + p->index = cnt; + mapping[cnt] = p; + } + pdata->in_pack_by_idx = mapping; +} + struct object_entry *packlist_alloc(struct packing_data *pdata, const unsigned char *sha1, uint32_t index_pos) { struct object_entry *new_entry; + if (!pdata->nr_objects) { + prepare_in_pack_by_idx(pdata); + if (getenv("GIT_TEST_OE_SIZE_BITS")) { + int bits = atoi(getenv("GIT_TEST_OE_SIZE_BITS"));; + pdata->oe_size_limit = 1 << bits; + } + if (!pdata->oe_size_limit) + pdata->oe_size_limit = 1 << OE_SIZE_BITS; + } if (pdata->nr_objects >= pdata->nr_alloc) { pdata->nr_alloc = (pdata->nr_alloc + 1024) * 3 / 2; REALLOC_ARRAY(pdata->objects, pdata->nr_alloc); + + if (!pdata->in_pack_by_idx) + REALLOC_ARRAY(pdata->in_pack, pdata->nr_alloc); } new_entry = pdata->objects + pdata->nr_objects++; @@ -107,5 +147,8 @@ struct object_entry *packlist_alloc(struct packing_data *pdata, else pdata->index[index_pos] = pdata->nr_objects; + if (pdata->in_pack) + pdata->in_pack[pdata->nr_objects - 1] = NULL; + return new_entry; } diff --git a/pack-objects.h b/pack-objects.h index af40211105..9f19672602 100644 --- a/pack-objects.h +++ b/pack-objects.h @@ -3,8 +3,9 @@ #define OE_DFS_STATE_BITS 2 #define OE_DEPTH_BITS 12 -#define OE_IN_PACK_BITS 14 +#define OE_IN_PACK_BITS 10 #define OE_Z_DELTA_BITS 16 +#define OE_SIZE_BITS 31 #define OE_DELTA_SIZE_BITS 31 /* @@ -35,7 +36,9 @@ enum dfs_state { * * "size" is the uncompressed object size. Compressed size of the raw * data for an object in a pack is not stored anywhere but is computed - * and made available when reverse .idx is made. + * and made available when reverse .idx is made. Note that when an + * delta is reused, "size" is the uncompressed _delta_ size, not the + * canonical one after the delta has been applied. * * "hash" contains a path name hash which is used for sorting the * delta list and also during delta searching. Once prepare_pack() @@ -74,7 +77,8 @@ struct object_entry { void *delta_data; /* cached delta (uncompressed) */ off_t in_pack_offset; uint32_t hash; /* name hint hash */ - uint32_t size_; /* object uncompressed size _if_ size_valid is true */ + uint32_t size_:OE_SIZE_BITS; + unsigned size_valid:1; uint32_t delta_idx; /* delta base object */ uint32_t delta_child_idx; /* deltified objects who bases me */ uint32_t delta_sibling_idx; /* other deltified objects who @@ -83,24 +87,23 @@ struct object_entry { uint32_t delta_size_:OE_DELTA_SIZE_BITS; /* delta data size (uncompressed) */ uint32_t delta_size_valid:1; unsigned in_pack_idx:OE_IN_PACK_BITS; /* already in pack */ - unsigned size_valid:1; unsigned z_delta_size:OE_Z_DELTA_BITS; unsigned type_valid:1; unsigned type_:TYPE_BITS; + unsigned no_try_delta:1; unsigned in_pack_type:TYPE_BITS; /* could be delta */ unsigned preferred_base:1; /* * we do not pack this, but is available * to be used as the base object to delta * objects against. */ - unsigned no_try_delta:1; - unsigned char in_pack_header_size; unsigned tagged:1; /* near the very tip of refs */ unsigned filled:1; /* assigned write-order */ unsigned dfs_state:OE_DFS_STATE_BITS; + unsigned char in_pack_header_size; unsigned depth:OE_DEPTH_BITS; - /* size: 80, bit_padding: 16 bits */ + /* size: 80, bit_padding: 20 bits, holes: 1 bit */ }; struct packing_data { @@ -111,8 +114,17 @@ struct packing_data { uint32_t index_size; unsigned int *in_pack_pos; - int in_pack_count; - struct packed_git *in_pack[1 << OE_IN_PACK_BITS]; + + /* + * Only one of these can be non-NULL and they have different + * sizes. if in_pack_by_idx is allocated, oe_in_pack() returns + * the pack of an object using in_pack_idx field. If not, + * in_pack[] array is used the same way as in_pack_pos[] + */ + struct packed_git **in_pack_by_idx; + struct packed_git **in_pack; + + uintmax_t oe_size_limit; }; struct object_entry *packlist_alloc(struct packing_data *pdata, @@ -171,38 +183,27 @@ static inline void oe_set_in_pack_pos(const struct packing_data *pack, pack->in_pack_pos[e - pack->objects] = pos; } -static inline unsigned int oe_add_pack(struct packing_data *pack, - struct packed_git *p) -{ - if (pack->in_pack_count >= (1 << OE_IN_PACK_BITS)) - die(_("too many packs to handle in one go. " - "Please add .keep files to exclude\n" - "some pack files and keep the number " - "of non-kept files below %d."), - 1 << OE_IN_PACK_BITS); - if (p) { - if (p->index > 0) - die("BUG: this packed is already indexed"); - p->index = pack->in_pack_count; - } - pack->in_pack[pack->in_pack_count] = p; - return pack->in_pack_count++; -} - static inline struct packed_git *oe_in_pack(const struct packing_data *pack, const struct object_entry *e) { - return pack->in_pack[e->in_pack_idx]; + if (pack->in_pack_by_idx) + return pack->in_pack_by_idx[e->in_pack_idx]; + else + return pack->in_pack[e - pack->objects]; } -static inline void oe_set_in_pack(struct object_entry *e, +static inline void oe_set_in_pack(struct packing_data *pack, + struct object_entry *e, struct packed_git *p) { - if (p->index <= 0) - die("BUG: found_pack should be NULL " - "instead of having non-positive index"); - e->in_pack_idx = p->index; + if (pack->in_pack_by_idx) { + if (p->index <= 0) + die("BUG: found_pack should be NULL " + "instead of having non-positive index"); + e->in_pack_idx = p->index; + } else + pack->in_pack[e - pack->objects] = p; } @@ -263,56 +264,49 @@ static inline void oe_set_delta_sibling(struct packing_data *pack, e->delta_sibling_idx = 0; } -static inline unsigned long oe_size(const struct object_entry *e) +unsigned long oe_get_size_slow(struct packing_data *pack, + const struct object_entry *e); +static inline unsigned long oe_size(struct packing_data *pack, + const struct object_entry *e) { - if (e->size_valid) { + if (e->size_valid) return e->size_; - } else { - unsigned long size; - sha1_object_info(e->idx.oid.hash, &size); - return size; - } + return oe_get_size_slow(pack, e); } -static inline int oe_fits_in_32bits(unsigned long limit) +static inline int oe_size_less_than(struct packing_data *pack, + const struct object_entry *lhs, + unsigned long rhs) { - uint32_t truncated_limit = (uint32_t)limit; - - return limit == truncated_limit; -} - -static inline int oe_size_less_than(const struct object_entry *e, - unsigned long limit) -{ - if (e->size_valid) - return e->size_ < limit; - if (oe_fits_in_32bits(limit)) /* limit < 2^32 <= size ? */ + if (lhs->size_valid) + return lhs->size_ < rhs; + if (rhs < pack->oe_size_limit) /* rhs < 2^x <= lhs ? */ return 0; - return oe_size(e) < limit; + return oe_get_size_slow(pack, lhs) < rhs; } -static inline int oe_size_greater_than(const struct object_entry *e, - unsigned long limit) +static inline int oe_size_greater_than(struct packing_data *pack, + const struct object_entry *lhs, + unsigned long rhs) { - if (e->size_valid) - return e->size_ > limit; - if (oe_fits_in_32bits(limit)) /* limit < 2^32 <= size ? */ + if (lhs->size_valid) + return lhs->size_ > rhs; + if (rhs < pack->oe_size_limit) /* rhs < 2^x <= lhs ? */ return 1; - return oe_size(e) > limit; + return oe_get_size_slow(pack, lhs) > rhs; } -static inline void oe_set_size(struct object_entry *e, +static inline void oe_set_size(struct packing_data *pack, + struct object_entry *e, unsigned long size) { - e->size_ = size; - e->size_valid = e->size_ == size; - - if (!e->size_valid) { - unsigned long real_size; - - if (sha1_object_info(e->idx.oid.hash, &real_size) < 0 || - size != real_size) + if (size < pack->oe_size_limit) { + e->size_ = size; + e->size_valid = 1; + } else { + e->size_valid = 0; + if (oe_get_size_slow(pack, e) != size) die("BUG: 'size' is supposed to be the object size!"); } } @@ -322,7 +316,7 @@ static inline unsigned long oe_delta_size(struct packing_data *pack, { if (e->delta_size_valid) return e->delta_size_; - return oe_size(e); + return oe_size(pack, e); } static inline void oe_set_delta_size(struct packing_data *pack, @@ -331,7 +325,7 @@ static inline void oe_set_delta_size(struct packing_data *pack, { e->delta_size_ = size; e->delta_size_valid = e->delta_size_ == size; - if (!e->delta_size_valid && size != oe_size(e)) + if (!e->delta_size_valid && size != oe_size(pack, e)) die("BUG: this can only happen in check_object() " "where delta size is the same as entry size"); } diff --git a/t/README b/t/README index 1a1361a806..da117ca734 100644 --- a/t/README +++ b/t/README @@ -292,6 +292,26 @@ and know what setup is needed for it. Or when you want to run everything up to a certain test. +Running tests with special setups +--------------------------------- + +The whole test suite could be run to test some special features +that cannot be easily covered by a few specific test cases. These +could be enabled by running the test suite with correct GIT_TEST_ +environment set. + +GIT_TEST_SPLIT_INDEX forces split-index mode on the whole test suite. + +GIT_TEST_FULL_IN_PACK_ARRAY exercises the uncommon pack-objects code +path where there are more than 1024 packs even if the actual number of +packs in repository is below this limit. + +GIT_TEST_OE_SIZE_BITS=<bits> exercises the uncommon pack-objects +code path where we do not cache objecct size in memory and read it +from existing packs on demand. This normally only happens when the +object size is over 2GB. This variable forces the code path on any +object larger than 2^<bits> bytes. + Naming Tests ------------ diff --git a/t/t5300-pack-object.sh b/t/t5300-pack-object.sh index 9c68b99251..5c076637ff 100755 --- a/t/t5300-pack-object.sh +++ b/t/t5300-pack-object.sh @@ -457,6 +457,11 @@ test_expect_success !PTHREADS,C_LOCALE_OUTPUT 'pack-objects --threads=N or pack. grep -F "no threads support, ignoring pack.threads" err ' +test_expect_success 'pack-objects in too-many-packs mode' ' + GIT_TEST_FULL_IN_PACK_ARRAY=1 git repack -ad && + git fsck +' + # # WARNING! # Nguyễn Thái Ngọc Duy (13): pack-objects: a bit of document about struct object_entry pack-objects: turn type and in_pack_type to bitfields pack-objects: use bitfield for object_entry::dfs_state pack-objects: use bitfield for object_entry::depth pack-objects: move in_pack_pos out of struct object_entry pack-objects: move in_pack out of struct object_entry pack-objects: refer to delta objects by index instead of pointer pack-objects: shrink z_delta_size field in struct object_entry pack-objects: don't check size when the object is bad pack-objects: clarify the use of object_entry::size pack-objects: shrink size field in struct object_entry pack-objects: shrink delta_size field in struct object_entry pack-objects: reorder members to shrink struct object_entry Documentation/config.txt | 4 +- Documentation/git-pack-objects.txt | 4 +- Documentation/git-repack.txt | 4 +- builtin/pack-objects.c | 353 +++++++++++++++++++---------- cache.h | 3 + object.h | 1 - pack-bitmap-write.c | 14 +- pack-bitmap.c | 2 +- pack-bitmap.h | 4 +- pack-objects.c | 43 ++++ pack-objects.h | 306 ++++++++++++++++++++++--- t/README | 10 + t/t5300-pack-object.sh | 5 + 13 files changed, 588 insertions(+), 165 deletions(-)
-- 2.17.0.rc0.348.gd5a49e0b6f