-
-## 接口/函数设计
-
-### 4.1 字段功能
+#### 数据结构
+ `class Fields`
@@ -133,86 +102,1434 @@
};
```
-### 4.2 KV 分离
+#### 字段测试
+
++ 编写的测试样例包括：字段的排序、批量写入、批量更新、批量删除、序列化/反序列化、包含 LSM-tree 和 KV 分离的 VLogs 范围的 `FindKeysByFields` 功能，全部通过。
+
+
+
+
+## KV 分离
+
+> KV 分离部分，由于我们小组最后定版设计为，使 VLog 代替原 LevelDB 中 WAL 的作用，同时具有从 LSM-Tree 中分离并保存超过某个 value 大小阈值（`separate_threshold`）的 kv 对数据的作用，关于 VLog 的读写类 `VlogReader/VlogWriter` 的实现参考了 `LogReader/LogWriter` 的部分内容，并能共享 `LogReader/LogWriter` 使用的所有读写接口（参见`env_posix.cc`，读写均为磁盘I/O）（去除了 CRC 校验功能）。
+>
+> + **结构图/写入流程图**：
+> 
+
+## VlogReader & VlogWriter
+
+### Vlog 结构图
+
+
+
+#### 数据格式
+
++ **VLog 文件大小：`Options::max_value_log_size = 16 * 1024 * 1024`；**
++ **KV 分离的 value 大小阈值为：`WriteOptions::separate_threshold = 32`；**
+
+```markdown
+vlog_record :
+ length: uint16 // record 长度
+ first_seq: uint64 // record 中第一对 kv 对应的 sequence
+ kv_count： uint16 // record 中的 kv 对数
+ kv_data: // record 保存的 kv 数据
+
+kv_data ：
+ type: uint8 // 是否进行 kv 分离
+ key_size: uint16 // key 的长度
+ key: // key 值
+ value_size: uint16 // value 的长度
+ value: // value 值
+
+LSM-tree 中的 value ：
+ // 若 KV 不分离，value 为原值编码，如需要分离则 value 编码保存为：
+value:
+ fid: uint64 // 保存该 kv 的 vlog 编号
+ offset: uint64 // 该 kv 起始位置在 vlog 中的偏移
+ value_size: uint64 // value 大小
+```
+
+### VlogReader
+
+```c++
+class VlogReader {
+ public:
+ class Reporter {
+ public:
+ virtual ~Reporter() = default;
+ virtual void Corruption(size_t bytes, const Status& status) = 0;
+ };
+
+ // 支持随机读与顺序读，提升顺序读取的效率
+ explicit VlogReader(SequentialFile* file, Reporter* reporter);
+ explicit VlogReader(RandomAccessFile* file, Reporter* reporter);
+
+ VlogReader(const VlogReader&) = delete;
+ VlogReader& operator=(const VlogReader&) = delete;
+
+ ~VlogReader();
+ // 从 vlog 中读取一条具体的值
+ bool ReadValue(uint64_t offset, size_t length, Slice* key_value, char* scratch);
+ bool ReadRecord(Slice* record, std::string* scratch);
+ // 返回 ReadRecord 函数读取的最后一条 record 的偏移（last_record_offset_）
+ uint64_t LastRecordOffset() const;
+
+ private:
+ /* 读取 vlog 物理记录（data 部分） */
+ bool ReadPhysicalRecord(std::string* result);
+
+ void ReportCorruption(uint64_t bytes, const Status &reason);
-+ 大 value 的 key 对应的 value 存储位置：`VPtr`
+ SequentialFile* const file_;
+ RandomAccessFile* const file_random_;
+ Reporter* const reporter_;
+ char* const backing_store_;
+ Slice buffer_;
+ bool eof_; // Last Read() indicated EOF by returning < kBlockSize
+
+ // Offset of the last record returned by ReadRecord.
+ uint64_t last_record_offset_;
+};
+```
+
++ 保留了大部分 `LogReader` 的原函数，但由于 Vlog 的数据结构相对 WAL 有很大改变，譬如直接丢弃原来的 `RecordType` 枚举类型（`kZeroType, kFullType, kFirstType, kMiddleType, kLastType`），下面是几个重要函数的重写（关注 `eof_` 标识符和 VLog 的 Header (只包含 length)，`vHeaderSize = 4`）：
```c++
- struct VPtr {
- int fileno; // VLog 文件号
- uint64_t offset; // 偏移量
- };
+ // 从 vlog 中读取一条具体的值
+ bool VlogReader::ReadValue(uint64_t offset, size_t length, Slice *key_value, char *scratch) {
+ if (file_random_ == nullptr) {
+ return false;
+ }
+ /* 随机读取一个 RandomAccessFile，使用对应的读接口 Read 函数 */
+ Status status = file_random_->Read(offset, length, key_value, scratch);
+ if (!status.ok()) {
+ return false;
+ }
+ return true;
+ }
+
+ bool VlogReader::ReadRecord(Slice *record, std::string *scratch) {
+ if (ReadPhysicalRecord(scratch)) {
+ *record = *scratch;
+ return true;
+ }
+ return false;
+ }
+
+ /* 读取 vlog 物理记录（kv_data 部分） */
+ bool VlogReader::ReadPhysicalRecord(std::string *result) {
+ result->clear();
+ buffer_.clear();
+
+ char* tmp_head = new char[vHeaderSize];
+ /* 顺序读取一个 SequentialFile，使用对应的读接口 Read 函数 */
+ Status status = file_->Read(vHeaderSize, &buffer_, tmp_head);
+ if (!status.ok()) {
+ buffer_.clear();
+ ReportCorruption(kBlockSize, status);
+ eof_ = true;
+ return false;
+ } else if (buffer_.size() < vHeaderSize) {
+ eof_ = true;
+ }
+
+ if (!eof_) {
+ result->assign(buffer_.data(),buffer_.size());
+ uint32_t length = DecodeFixed32(buffer_.data());
+ buffer_.clear();
+ char* tmp = new char[length];
+ status = file_->Read(length, &buffer_, tmp);
+ if (status.ok() && buffer_.size() == length) {
+ *result += buffer_.ToString();
+ } else {
+ eof_ = true;
+ }
+ delete [] tmp;
+ }
+ delete [] tmp_head;
+
+ if (eof_) {
+ result->clear();
+ return false;
+ }
+ return true;
+ }
+ ```
+
+#### 读流程详解
+
+1. 一条传入 key 的读流程发起后，调用起始点是 `DBImpl::Get()` 函数，若成功在 memtable、immutable memtable、SSTables 里找到该 key 对应的 kv 对，且 kv 对的 `type` 为 `kTypeSeparation`：
+ ```c++
+ Status DBImpl::Get(const ReadOptions& options, const Slice& key,
+ std::string* value) {
+
+ ······
+
+ /* Vlog 读取 value */
+ if (s.ok() && s.IsSeparated()) {
+
+ struct VlogReporter : public VlogReader::Reporter {
+ Status* status;
+ void Corruption(size_t bytes, const Status& s) override {
+ if (this->status->ok()) *this->status = s;
+ }
+ };
+
+ VlogReporter reporter;
+ Slice vlog_ptr(*value);
+ uint64_t file_no;
+ uint64_t offset;
+ uint64_t val_size;
+ size_t key_size = key.size();
+
+ /* 已知该 value 保存在 VLog，解码出 vlog_ptr（fid, offset, val_size）*/
+ GetVarint64(&vlog_ptr, &file_no);
+ GetVarint64(&vlog_ptr, &offset);
+ GetVarint64(&vlog_ptr, &val_size);
+
+ /* VLog 内部 kv 对的编码长度，1B 为 type */
+ uint64_t encoded_len = 1 + VarintLength(key_size) + key.size() + VarintLength(val_size) + val_size;
+
+ std::string fname = LogFileName(dbname_, file_no);
+ RandomAccessFile* file;
+ s = env_->NewRandomAccessFile(fname,&file);
+ if (!s.ok()) {
+ return s;
+ }
+
+ VlogReader vlogReader(file, &reporter);
+ Slice key_value;
+ char* scratch = new char[encoded_len];
+
+ if (vlogReader.ReadValue(offset, encoded_len, &key_value, scratch)) {
+ value->clear();
+ if (!ParseVlogValue(key_value, key, *value, val_size)) {
+ s = Status::Corruption("value in vlog isn't match with given key");
+ }
+ } else {
+ s = Status::Corruption("read vlog error");
+ }
+
+ delete file;
+ file = nullptr;
+ }
+
+ return s;
+ }
+ ```
+
+2. VlogReader 读取了 VLog kv 数据对后，对该数据对进行解析，实现很简单，按序解码出 key 和 vlog_value 即可：
+ ```C++
+ /* 从 VlogReader 读取的 VLog kv 数据对中解析出 value */
+ bool DBImpl::ParseVlogValue(Slice key_value, Slice key,
+ std::string& value, uint64_t val_size) {
+ Slice k_v = key_value;
+ if (k_v[0] != kTypeSeparation) return false;
+ k_v.remove_prefix(1);
+
+ Slice vlog_key;
+ Slice vlog_value;
+ if (GetLengthPrefixedSlice(&k_v, &vlog_key)
+ && vlog_key == key
+ && GetLengthPrefixedSlice(&k_v, &vlog_value)
+ && vlog_value.size() == val_size) {
+ value = vlog_value.ToString();
+ return true;
+ } else {
+ return false;
+ }
+ }
+ ```
+
+### VlogWriter
+
+```c++
+class VlogWriter {
+ public:
+ // Create a writer that will append data to "*dest".
+ // "*dest" must be initially empty.
+ // "*dest" must remain live while this Writer is in use.
+ explicit VlogWriter(WritableFile* dest);
+
+ // Create a writer that will append data to "*dest".
+ // "*dest" must have initial length "dest_length".
+ // "*dest" must remain live while this Writer is in use.
+ VlogWriter(WritableFile* dest, uint64_t dest_length);
+
+ VlogWriter(const VlogWriter&) = delete;
+ VlogWriter& operator=(const VlogWriter&) = delete;
+
+ ~VlogWriter() = default;
+
+ Status AddRecord(const Slice& slice, uint64_t& offset);
+
+ private:
+ Status EmitPhysicalRecord(const char* ptr, size_t length, uint64_t& offset);
+ size_t head_;
+ WritableFile* dest_;
+};
+```
+
+VlogWriter的设计与LogWriter的设计基本相同，更多的其实是减去了校验码的部分。
+
+AddRecord()即写入一条日志，EmitPhysicalRecord()则是写入缓存区。
+
+head_记录当前文件写入位置（偏移量）以用于计算下一条记录的写入起始位置
+
+```c++
+VlogWriter::VlogWriter(WritableFile* dest) : dest_(dest), head_(0) {}
+
+VlogWriter::VlogWriter(WritableFile* dest, uint64_t dest_length)
+ : dest_(dest), head_(0) {}
+
+Status VlogWriter::AddRecord(const Slice& slice, uint64_t& offset) {
+ const char* ptr = slice.data();
+ size_t left = slice.size();
+ Status s;
+ s = EmitPhysicalRecord(ptr, left, offset);
+ return s;
+}
+
+Status VlogWriter::EmitPhysicalRecord(const char* ptr, size_t length,
+ uint64_t& offset) {
+ assert(length <= 0xffff);
+ char buf[4];
+ EncodeFixed32(buf, length);
+ Status s = dest_->Append(Slice(buf, 4));
+ if (s.ok()) {
+ s = dest_->Append(Slice(ptr, length));
+ if (s.ok()) {
+ s = dest_->Flush();
+ offset = head_ + 4;
+ head_ += 4 + length;
+ }
+ }
+ return s;
+}
+```
+
+vlog_writer.cc文件中则是对于构造函数，AddRecord()以及EmitPhysicalRecord()。实现上与LogWriter基本一致，只是去除了Crc校验码的部分。对于EmitPhysicalRecord()函数，由于去除了校验码，则其header要从原本的8字节改为4字节，只保留length部分（4字节）。
+
+改完vlog_writer部分后，让我们重新来梳理一遍写入过程。
+
+对于Put()操作：
+
+```c++
+// Convenience methods
+Status DBImpl::Put(const WriteOptions& o, const Slice& key, const Slice& val) {
+ return DB::Put(o, key, val);
+}
+```
+
+```c++
+Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice& value) {
+ WriteBatch batch(opt.separate_threshold);
+ batch.Put(key, value);
+ return Write(opt, &batch);
+}
+```
+
+经过一系列函数的调用，最终会来到Write()函数
+
+```c++
+Status DBImpl::Write(const WriteOptions& options, WriteBatch* updates) {
+ Writer w(&mutex_);
+ w.batch = updates;
+ w.sync = options.sync;
+ w.done = false;
+
+ MutexLock l(&mutex_);
+ writers_.push_back(&w);
+ while (!w.done && &w != writers_.front()) {
+ w.cv.Wait();
+ }
+ if (w.done) {
+ return w.status;
+ }
+
+ // May temporarily unlock and wait.
+ Status status = MakeRoomForWrite(updates == nullptr);
+ uint64_t last_sequence = versions_->LastSequence();
+ Writer* last_writer = &w;
+ ...
+```
+
+首先会生成一个writer对象,带写锁，并对writer进行初始化。
+
+在leveldb中，在面对并发写入时，做了一个处理的优化。在同一个时刻，只允许一个写入操作将内容写入到日志文件以及内存数据库中。为了在写入进程较多的情况下，减少日志文件的小写入，增加整体的写入性能，leveldb将一些“小写入”合并成一个“大写入”。使第一个发起写入的线程作为唯一写者，负责发起写合并、批量化处理来自其他线程的写入操作。
+
+紧接着便是MakeRoomForWrite 方法，判断 Memtable 是不是满了、当前 L0 的 SSTable 是不是太多了，从而发起 Compaction 或者限速。
+
+```c++
+...
+{
+ mutex_.Unlock();
+ // 先写入vlog再写入memtable
+ // 写vlog日志 offset 表示这个 write_batch 在vlog中的偏移地址。
+ uint64_t offset = 0;
+ status = vlog_->AddRecord(WriteBatchInternal::Contents(write_batch),offset);
+ // status = log_->AddRecord(WriteBatchInternal::Contents(write_batch));
+ bool sync_error = false;
+ if (status.ok() && options.sync) {
+ status = logfile_->Sync();
+ if (!status.ok()) {
+ sync_error = true;
+ }
+ }
+ if (status.ok()) {
+ status = WriteBatchInternal::InsertInto(write_batch, mem_, logfile_number_, offset);
+ }
+ ...
+```
+
+接着是写入Record部分，这里我们做了一个修改，即我们会先写入vlog再写入memtable。
+
+实现上是先调用AddRecord()将Record写入vlog，再调用InsertInto()写如memtable。
+
+对于InsertInto():
+
+```c++
+Status WriteBatchInternal::InsertInto(const WriteBatch* b, MemTable* memtable,
+ uint64_t fid, size_t offset) {
+ MemTableInserter inserter;
+ inserter.sequence_ = WriteBatchInternal::Sequence(b);
+ inserter.mem_ = memtable;
+ return b->Iterate(&inserter, fid, offset);
+}
+```
+
+会调用Iterate():
+
+```c++
+Status WriteBatch::Iterate(Handler* handler, uint64_t fid,
+ uint64_t offset) const {
+ Slice input(rep_);
+ const char* begin = input.data();
+
+ if (input.size() < kHeader) {
+ return Status::Corruption("malformed WriteBatch (too small)");
+ }
+ input.remove_prefix(kHeader);
+ Slice key, value;
+ int found = 0;
+ while (!input.empty()) {
+ found++;
+ const uint64_t kv_offset = input.data() - begin + offset;
+ assert(kv_offset > 0);
+
+ char tag = input[0];
+ input.remove_prefix(1);
+ switch (tag) {
+ case kTypeValue:
+ if (GetLengthPrefixedSlice(&input, &key) &&
+ GetLengthPrefixedSlice(&input, &value)) {
+ handler->Put(key, value);
+ } else {
+ return Status::Corruption("bad WriteBatch Put");
+ }
+ break;
+ case kTypeDeletion:
+ if (GetLengthPrefixedSlice(&input, &key)) {
+ handler->Delete(key);
+ } else {
+ return Status::Corruption("bad WriteBatch Delete");
+ }
+ break;
+ case kTypeSeparation:
+ if (GetLengthPrefixedSlice(&input, &key) &&
+ GetLengthPrefixedSlice(&input, &(value))) {
+ // value = fileNumber + offset + valuesize 采用变长编码的方式
+ std::string dest;
+ PutVarint64(&dest, fid);
+ PutVarint64(&dest, kv_offset);
+ PutVarint64(&dest, value.size());
+ Slice value_offset(dest);
+ handler->Put(key, value_offset, kTypeSeparation);
+ } else {
+ return Status::Corruption("WriteBatch Put error");
+ }
+ break;
+ default:
+ return Status::Corruption("unknown WriteBatch tag");
+ }
+ }
+ if (found != WriteBatchInternal::Count(this)) {
+ return Status::Corruption("WriteBatch has wrong count");
+ } else {
+ return Status::OK();
+ }
+}
+```
+
+在Iterate()中,对于每次操作进行遍历，对于不同的keyType会进行不同的处理，这里我们对于kTypeSeparation类型，即超过阈值需要进行kv分离的键值对，会对value进行修改，使其采用fileNumber + offset + valuesize 变长编码的方式，最后调用Put写入memtable。
+
+### KV 分离读写测试
+
++ VLog 读写测试文件为 `test/kv_test`，长/短 value 读写均通过测试，KV 分离实现。
+
+
+
+
+
+## Garbage Collection
+
+> 不同于 VLog 已实现 `VlogReader/VlogWriter` 的读写功能，我们设计 VLog 的垃圾回收机制（GC）是基于每个 VLog 的剩下有效 kv 数据对所占 VLog 比重触发的。
+
+#### ValueLogInfo
+
++ GC 需要知晓每个 VLog 的详细信息，这些信息以结构体 `ValueLogInfo` 的形式保存与访问：
+
+ ```C++
+ typedef struct ValueLogInfo {
+ uint64_t last_sequence_; // VLog 中最后一个有效 kv 的序列号
+ size_t file_size_; // VLog 文件大小
+ uint64_t logfile_number_; // VLog 文件编号
+ int left_kv_numbers_; // VLog 中剩下的 kv 数量
+ uint64_t invalid_memory_; // VLog 中无效空间的大小
+ }ValueLogInfo;
```
-+ `class VLog`
++ 所有 VLog 文件的 `ValueLogInfo` 可以根据对应的 `ValueLogInfo->invalid_memory_` 进行对比，并从小到大保存：
```c++
- class VLog {
- private:
- // 该 VLog 是否活跃，即可插值
- bool activate_;
-
- // 最大 VLog 大小
- std::size_t maxSize_;
-
- // GC 计数器
- std::size_t deadkeyCount;
-
- public:
- // 构造函数，默认赋值 GC 计数器为 GC 触发的最大阈值
- VLog(bool activate, std::size_t maxSize, std::size_t gcThreshold)
- : activate_(activate), maxSize_(maxSize), deadkeyCount(gcThreshold) {}
-
- // 向 VLog 中添加一个新的键值对
- virtual void append(const std::string& key, const std::string& value) = 0;
-
- // 查找给定键对应的值
- virtual VPtr lookup(const std::string& key) const = 0;
-
- // 执行垃圾回收操作
- virtual void GarbageCollection() = 0;
-
- virtual ~VLog() {}
+ struct MapCmp{
+ bool operator ()(const ValueLogInfo* a, const ValueLogInfo* b)
+ {
+ return a->invalid_memory_ < b->invalid_memory_;
+ }
};
```
-## 功能测试
-
-### 单元测试（测试用例）
-
-+ **字段功能：**
- 1. （测试是否能序列化 `FieldArray`、反序列化解析 value ；）
- 2. 测试是否能成功写入、点查与范围查询；
- 3. 测试是否能通过 value 查询所有匹配的 Key。
-+ **KV 分离：**
- 1. 测试大小 value 与对应 key 是否按规则存入 LSM-Tree 或 VLog；
- 2. 测试是否能通过 key 与 `VPtr` 找到 VLog 中正确的 value；
- 3. 测试 GC 流程是否正确，包括是否成功触发、重写 VLog、回写 LSM-Tree 的 key 对应的 `VPtr`。
-
-### 性能测试（Benchmark）
-
-1. 测试不同 value 大小的 Throughput；
-2. 测试读写放大的减小程度；
-3. 测试随着插入数据量，LSM-Tree 层级的减小程度；
-4. 测试随机点查 / 顺序范围查询效率；
-5. 测试 GC 开销；
-6. 测试各读写阶段耗时占比（Wait / Log / Memtable / Other）；
-7. 比较大/小数据集、高并发场景的表现；
-8. （比较资源利用率（硬盘 I/O 、内存负载）；）
-
-## 可能遇到的挑战与解决方案
-
-1. KV 分离中 VLog 的 GC 开销可能较大：GC 过程中需要扫描和重写 vLog，以及回写 LSM-Tree，需要遍历所有 SSTable，开销较大；
-2. 数据一致性问题：若程序突然停止运行，可能导致数据不一致的情况，目前暂时没想到恢复机制；
-3. 读、写、GC 等流程的持锁处理；
-4. 由于每次读取需要遍历整个 LSM-Tree 且由于 vLog 是 Append-Only 的无序存储，导致顺序读取的效率可能不比随机读取高多少，开销大，需要实现 value 预读机制，提前预读取下一个 value。
-
-## 分工和进度安排
-
-| 功能 | 预计完成日期 | 分工 |
-| :------------------------------------------: | :----------: | :----------: |
-| Fields 类和相关接口实现 | 12月3日 | 朱维清、谷杰 |
-| 测试实现字段功能 | 12月5日 | 谷杰 |
-| VLog 类和相关接口实现 | 12月15日 | 朱维清、谷杰 |
-| 测试实现 KV 分离 | 12月19日 | 朱维清 |
-| Benchmark 测试（吞吐量、写放大、点查范围查） | 12月26日 | 谷杰 |
-| Benchmark 测试（GC 开销、大小数据集、并发） | 12月26日 | 朱维清 |
\ No newline at end of file
+### SeparateManagement 类
+
+```C++
+class SeparateManagement {
+ public:
+ SeparateManagement(uint64_t garbage_collection_threshold)
+ : garbage_collection_threshold_(garbage_collection_threshold) {}
+
+ ~SeparateManagement() {}
+ /* 更新数据库的最后一个序列号，为需要 GC 的 VLog 分配新的序列号 */
+ bool ConvertQueue(uint64_t& db_sequence);
+ /* 更新指定 VLogInfo 的无效空间和剩余键值对数量 */
+ void UpdateMap(uint64_t fid, uint64_t abandon_memory);
+ /* 选择无效空间最大的 VLog 加入到 need_updates_ 队列 */
+ void UpdateQueue(uint64_t fid);
+ /* 从 garbage_collection_ 队列中取出一个需要 GC 的 VLog，返回最后（最新）序列号 */
+ bool GetGarbageCollectionQueue(uint64_t& fid, uint64_t& last_sequence);
+ /* 在 map_file_info_ 中添加新创建的 VLog 的 ValueLogInfo */
+ void WriteFileMap(uint64_t fid, int kv_numbers, size_t log_memory);
+ /* 检查是否有任何 VLog 需要 GC */
+ bool MayNeedGarbageCollection() { return !garbage_collection_.empty(); }
+ /* 从 map_file_info_ 中移除指定编号的 VLog */
+ void RemoveFileFromMap(uint64_t fid) { map_file_info_.erase(fid); }
+ /* 检查 map_file_info_ 是否为空 */
+ bool EmptyMap() { return map_file_info_.empty(); }
+ /* 遍历 map_file_info_ 中的所有 VLog，更新 need_updates_ 以便后续 GC */
+ void CollectionMap();
+
+ private:
+ // VLog 触发 GC 的阈值
+ uint64_t garbage_collection_threshold_;
+ // 当前 version 的所有 VLog 索引
+ std::unordered_mapAK4e#I6A9QGA
z2{D96nl+zG(~q%`T0%l)+2;XbVxie`-{Kcj;TiAEWb
zlOt)0#vl8uW7=u*KO%GKi?6%2#iZ%)Y?WiQ%tp%`*iGAT&PXe+vpedZ+})!I83pe+
zn3>qNhWC^O%Vb*&OGM^4#5Ot@S-XpN&5U;y36e;r@lEci9${b5a(iF`m~3mkTz($6
zK;o4l1tiVAvQh)FtDSG$%@@1MG0aR3tt50Kg*$B3`a6qwnhhBN_e<@ay_27iGjaOR
zg$M<|RyD4}=81c38{Bfdl&Fv?$f;CB%!k3Ldi9wl&E$oTDj$-nd#3j14zU~>c`Gwl
zXrCXd1y6HqAd${G{vpfUz`DbgDrAUoGP4F^U3)eOAZWZ 0)=FI#3GFB;$|+HJEJT%(+U$mDIB4-@0qoUsY)R1aJ-mMMm_An_CYz
z_0!*?KF`&eV6>G+Kta1AO!awm4fB};>QoFHN%vpr<>&MY