From 8f99e09ba7b3cc95a763f5bd0e849b7781f58675 Mon Sep 17 00:00:00 2001 From: A-Words Date: Fri, 7 Aug 2026 20:08:06 +0800 Subject: [PATCH 01/25] feat(sft): add pair-aware DPO training --- relax/backends/megatron/actor.py | 69 +-- relax/backends/megatron/data.py | 119 +++++ relax/backends/megatron/loss.py | 85 +++- relax/components/actor.py | 8 +- relax/components/sft.py | 70 ++- relax/engine/sft/bootstrap.py | 14 +- relax/engine/sft/dataset/preference.py | 421 ++++++++++++++++++ relax/engine/sft/runtime.py | 67 +++ relax/utils/arguments.py | 23 + relax/utils/data/stream_dataloader.py | 9 + relax/utils/training/data_fields.py | 10 + relax/utils/training/preference_utils.py | 112 +++++ .../data/prepare_ultrafeedback_preferences.py | 159 +++++++ .../dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 61 +++ .../megatron/test_sft_train_data_fields.py | 44 ++ tests/engine/sft/dataset/test_preference.py | 198 ++++++++ tests/engine/sft/test_preference_runtime.py | 77 ++++ tests/utils/training/test_preference_utils.py | 80 ++++ 18 files changed, 1582 insertions(+), 44 deletions(-) create mode 100644 relax/engine/sft/dataset/preference.py create mode 100644 relax/utils/training/preference_utils.py create mode 100644 scripts/data/prepare_ultrafeedback_preferences.py create mode 100644 scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh create mode 100644 tests/engine/sft/dataset/test_preference.py create mode 100644 tests/engine/sft/test_preference_runtime.py create mode 100644 tests/utils/training/test_preference_utils.py diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index 1c1355426..7b26f7401 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -33,6 +33,7 @@ from relax.engine.sft.eval.runner import run_sft_eval from relax.engine.sft.predict.runner import run_sft_predict from relax.engine.sft.runtime import ( + is_preference_mode, is_sft_mode, sft_partition_id, sft_task_name, @@ -84,6 +85,7 @@ DataIterator, build_rollout_minibatch_plan, concat_rollout_batches, + expand_preference_rollout_data, get_data_iterator, log_perf_data, log_perf_data_fwd, @@ -267,7 +269,15 @@ def _init( self.weights_backuper.backup("actor") if with_ref: - self.load_other_checkpoint("ref", args.ref_load) + if is_preference_mode(args) and args.sft_objective == "dpo": + if loaded_rollout_id < 0: + self.weights_backuper.backup("ref") + else: + self.load_other_checkpoint("ref", args.hf_checkpoint) + self._active_model_tag = "ref" + self._switch_model("actor") + else: + self.load_other_checkpoint("ref", args.ref_load) # Load teacher model for Megatron-based on-policy distillation if with_opd_teacher: @@ -776,6 +786,9 @@ def train_critic(self, rollout_id: int, rollout_data: RolloutBatch) -> None: self.sleep() def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: + if is_preference_mode(self.args): + rollout_data = expand_preference_rollout_data(rollout_data) + # PPO colocate: ``values`` and ``loss_masks`` reach us via TransferQueue # and land on CPU (critic ``.cpu()`` s ``values`` before PUT). Inline # GAE + normalize_advantages need GPU tensors — dispatch here so the @@ -808,7 +821,10 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: with inverse_timer("train_wait"), timer("train"): # All RL algorithms need ref/teacher/actor inline forwards to produce old_log_probs. - should_compute_old_log_probs = self.args.compute_advantages_and_returns + standard_dpo = ( + is_preference_mode(self.args) and self.args.sft_objective == "dpo" and not self.args.dpo_reference_free + ) + should_compute_old_log_probs = self.args.compute_advantages_and_returns or standard_dpo # PPO fully_async has a standalone Advantages service that produces # advantages/returns via TransferQueue; every other path (including # PPO colocate) computes GAE inline from critic's ``values``. @@ -844,7 +860,7 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: ) self._switch_model("old_actor" if self.args.keep_old_actor else "actor") - if not self.args.use_rollout_logprobs or self.args.get_mismatch_metrics: + if not standard_dpo and (not self.args.use_rollout_logprobs or self.args.get_mismatch_metrics): if self.args.use_routing_replay: if self.args.use_rollout_routing_replay: os.environ["ROUTING_REPLAY_STAGE"] = "replay_forward" @@ -1846,30 +1862,31 @@ def recv_weight_fully_async(self, rollout_id) -> None: def load_other_checkpoint(self, model_tag: str, path: str) -> None: old_args = self.args.load, self.args.no_load_optim, self.args.no_load_rng, self.args.finetune - self.args.load = path - self.args.no_load_optim = True - self.args.no_load_rng = True - self.args.finetune = True - old_ckpt_step = None - if model_tag == "ref" and self.args.ref_ckpt_step is not None: - old_ckpt_step = self.args.ckpt_step - self.args.ckpt_step = self.args.ref_ckpt_step - elif model_tag == "teacher" and self.args.opd_teacher_ckpt_step is not None: - old_ckpt_step = self.args.ckpt_step - self.args.ckpt_step = self.args.opd_teacher_ckpt_step - - _, _ = load_checkpoint( - self.model, - None, - None, - checkpointing_context={}, - skip_load_to_model_and_opt=False, - ) - self.args.load, self.args.no_load_optim, self.args.no_load_rng, self.args.finetune = old_args - - if old_ckpt_step is not None: - self.args.ckpt_step = old_ckpt_step + try: + self.args.load = path + self.args.no_load_optim = True + self.args.no_load_rng = True + self.args.finetune = True + + if model_tag == "ref" and self.args.ref_ckpt_step is not None: + old_ckpt_step = self.args.ckpt_step + self.args.ckpt_step = self.args.ref_ckpt_step + elif model_tag == "teacher" and self.args.opd_teacher_ckpt_step is not None: + old_ckpt_step = self.args.ckpt_step + self.args.ckpt_step = self.args.opd_teacher_ckpt_step + + _, _ = load_checkpoint( + self.model, + None, + None, + checkpointing_context={}, + skip_load_to_model_and_opt=False, + ) + finally: + self.args.load, self.args.no_load_optim, self.args.no_load_rng, self.args.finetune = old_args + if old_ckpt_step is not None: + self.args.ckpt_step = old_ckpt_step self.weights_backuper.backup(model_tag) self._active_model_tag = model_tag diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index 9aff3da6f..d254ca1b8 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -25,6 +25,7 @@ from relax.utils.timer import Timer from relax.utils.training import train_metric_utils from relax.utils.training.flops_counter import FlopsCounter +from relax.utils.training.preference_utils import pack_preference_pair_indices from relax.utils.types import RolloutBatch from .cp_utils import ( @@ -703,6 +704,117 @@ def reset(self) -> "DataIterator": return self +def expand_preference_rollout_data(rollout_data: RolloutBatch) -> RolloutBatch: + """Expand pair rows into adjacent chosen/rejected model sequences.""" + if "preference_pair_costs" in rollout_data: + return rollout_data + required = ( + "pair_ids", + "chosen_tokens", + "rejected_tokens", + "chosen_loss_masks", + "rejected_loss_masks", + "chosen_total_lengths", + "rejected_total_lengths", + ) + missing = [key for key in required if key not in rollout_data] + if missing: + raise ValueError(f"preference rollout data is missing fields: {missing}") + pair_count = len(rollout_data["pair_ids"]) + if pair_count <= 0: + raise ValueError("preference rollout batch must contain at least one pair") + for key in required: + if len(rollout_data[key]) != pair_count: + raise ValueError( + f"preference field {key!r} is not pair-row aligned: expected {pair_count}, got {len(rollout_data[key])}" + ) + + flat: RolloutBatch = { + "tokens": [], + "loss_masks": [], + "total_lengths": [], + "response_lengths": [], + "preference_branch_pair_ids": [], + "preference_is_chosen": [], + } + pair_costs: list[int] = [] + pair_ids: list[int] = [] + for index in range(pair_count): + chosen_length = int(rollout_data["chosen_total_lengths"][index]) + rejected_length = int(rollout_data["rejected_total_lengths"][index]) + if chosen_length <= 0 or rejected_length <= 0: + raise ValueError(f"preference pair row {index} has non-positive branch length") + pair_id = int(rollout_data["pair_ids"][index]) + pair_ids.append(pair_id) + pair_costs.append(chosen_length + rejected_length) + for prefix, is_chosen in (("chosen", True), ("rejected", False)): + tokens = rollout_data[f"{prefix}_tokens"][index] + loss_mask = rollout_data[f"{prefix}_loss_masks"][index] + total_length = int(rollout_data[f"{prefix}_total_lengths"][index]) + if len(tokens) != total_length or len(loss_mask) != total_length: + raise ValueError( + f"preference pair row {index} {prefix} tensor length does not match declared total_length" + ) + flat["tokens"].append(tokens) + flat["loss_masks"].append(loss_mask) + flat["total_lengths"].append(total_length) + flat["response_lengths"].append(total_length) + flat["preference_branch_pair_ids"].append(pair_id) + flat["preference_is_chosen"].append(is_chosen) + flat["preference_pair_costs"] = pair_costs + flat["preference_pair_ids"] = pair_ids + return flat + + +def _split_preference_bins_to_count(bins: list[list[int]], target_count: int) -> list[list[int]]: + bins = [list(group) for group in bins] + while len(bins) < target_count: + candidates = [(len(group), -index, index) for index, group in enumerate(bins) if len(group) > 1] + if not candidates: + raise RuntimeError( + f"cannot split {len(bins)} preference micro-batches to DP-synchronized count {target_count}" + ) + _, _, index = max(candidates) + group = bins[index] + bins[index] = group[:-1] + bins.insert(index + 1, [group[-1]]) + return bins + + +def _get_preference_data_iterator( + args: Namespace, + rollout_data: RolloutBatch, + max_tokens_per_gpu: int | None, +) -> tuple[list[DataIterator], list[int]]: + pair_costs = [int(cost) for cost in rollout_data["preference_pair_costs"]] + pair_ids = [str(pair_id) for pair_id in rollout_data["preference_pair_ids"]] + dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) + if int(args.global_batch_size) % dp_size != 0: + raise ValueError("pair-valued global batch size must be divisible by data parallel size") + expected_local_pairs = int(args.global_batch_size) // dp_size + if len(pair_costs) != expected_local_pairs: + raise ValueError( + "preference local pair count does not match pair-valued global batch size: " + f"local={len(pair_costs)}, expected={expected_local_pairs}, dp_size={dp_size}" + ) + capacity = int(max_tokens_per_gpu or args.max_tokens_per_gpu) + pair_bins = pack_preference_pair_indices(pair_costs, pair_ids, capacity=capacity) + bin_count = torch.tensor([len(pair_bins)], dtype=torch.int, device=device_utils.make_current_torch_device()) + dist.all_reduce(bin_count, op=dist.ReduceOp.MAX, group=mpu.get_data_parallel_group()) + pair_bins = _split_preference_bins_to_count(pair_bins, int(bin_count.item())) + branch_bins = [ + [branch for pair_index in group for branch in (2 * pair_index, 2 * pair_index + 1)] for group in pair_bins + ] + covered = [index for group in pair_bins for index in group] + if sorted(covered) != list(range(len(pair_costs))): + raise RuntimeError("preference dynamic batching lost or duplicated a pair") + for group in branch_bins: + if len(group) % 2 != 0 or any(group[index + 1] != group[index] + 1 for index in range(0, len(group), 2)): + raise RuntimeError("preference dynamic batching split a chosen/rejected pair") + iterator = DataIterator(rollout_data, micro_batch_indices=branch_bins, max_tokens_per_gpu=capacity) + return [iterator], [len(branch_bins)] + + def get_data_iterator( args: Namespace, model: torch.nn.Module | Sequence[torch.nn.Module], @@ -722,6 +834,9 @@ def get_data_iterator( - `data_iterators`: list of `DataIterator`, one per VPP stage (size 1 if VPP disabled) - `num_microbatches`: list[int], one per local step in the rollout (length = steps) """ + if getattr(args, "loss_type", None) == "sft" and getattr(args, "sft_objective", "causal_lm") == "dpo": + return _get_preference_data_iterator(args, rollout_data, max_tokens_per_gpu) + dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) dp_group = mpu.get_data_parallel_group() vpp_size = mpu.get_virtual_pipeline_model_parallel_world_size() @@ -917,6 +1032,10 @@ def log_rollout_data( ROLLOUT_MINI_LOCAL_SAMPLE_COUNTS_KEY, ROLLOUT_MINI_GLOBAL_SAMPLE_COUNTS_KEY, ROLLOUT_MINI_PROMPT_GROUP_COUNTS_KEY, + "preference_pair_costs", + "preference_pair_ids", + "preference_branch_pair_ids", + "preference_is_chosen", ]: continue if args.use_opd and key in OPD_ROLLOUT_LOG_SKIP_FIELDS: diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 735b9a052..0075619de 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -32,6 +32,7 @@ get_reinforce_plus_plus_baseline_advantages, get_reinforce_plus_plus_returns, ) +from relax.utils.training.preference_utils import dpo_pair_loss from relax.utils.types import RolloutBatch from .cp_utils import ( @@ -1178,6 +1179,82 @@ def sft_loss_function( ) +def dpo_loss_function( + args: Namespace, + batch: RolloutBatch, + logits: torch.Tensor, + sum_of_sample_mean: Callable[[torch.Tensor], torch.Tensor], # noqa: ARG001 +) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: + """Compute a pair-summed DPO objective over adjacent chosen/rejected + branches.""" + if len(batch["response_lengths"]) % 2 != 0: + raise ValueError("DPO micro-batch must contain an even number of chosen/rejected branches") + _, values = get_log_probs_and_entropy( + logits, + args=args, + unconcat_tokens=batch["unconcat_tokens"], + total_lengths=batch["total_lengths"], + response_lengths=batch["response_lengths"], + with_entropy=False, + max_seq_lens=batch.get("max_seq_lens", None), + padded_total_lengths=batch.get("padded_total_lengths", None), + dynamic_cp_size=batch.get("dynamic_cp_size", None), + dynamic_cp_rank=batch.get("dynamic_cp_rank", None), + ) + policy_token_log_probs = values["log_probs"] + + def sequence_sums(token_values) -> torch.Tensor: + if len(token_values) != len(batch["loss_masks"]): + raise ValueError("DPO token log-probabilities are not branch aligned") + sums = [] + for branch_values, mask in zip(token_values, batch["loss_masks"], strict=True): + branch_values = torch.as_tensor(branch_values, device=logits.device) + branch_mask = mask.to(device=logits.device, dtype=branch_values.dtype) + if branch_values.shape != branch_mask.shape: + raise ValueError( + "DPO branch log-probability/mask shape mismatch: " + f"{tuple(branch_values.shape)} vs {tuple(branch_mask.shape)}" + ) + sums.append((branch_values * branch_mask).sum()) + return torch.stack(sums) + + policy_sums = sequence_sums(policy_token_log_probs) + policy_chosen, policy_rejected = policy_sums[0::2], policy_sums[1::2] + reference_free = bool(args.dpo_reference_free) + if reference_free: + reference_chosen = reference_rejected = None + ref_chosen_for_metrics = torch.zeros_like(policy_chosen) + ref_rejected_for_metrics = torch.zeros_like(policy_rejected) + else: + reference_values = batch.get("ref_log_probs") + if reference_values is None: + raise ValueError("standard DPO batch is missing frozen-reference log-probabilities") + reference_sums = sequence_sums(reference_values) + reference_chosen, reference_rejected = reference_sums[0::2], reference_sums[1::2] + ref_chosen_for_metrics = reference_chosen + ref_rejected_for_metrics = reference_rejected + pair_losses = dpo_pair_loss( + policy_chosen, + policy_rejected, + reference_chosen=reference_chosen, + reference_rejected=reference_rejected, + beta=args.dpo_beta, + reference_free=reference_free, + ) + chosen_rewards = args.dpo_beta * (policy_chosen - ref_chosen_for_metrics) + rejected_rewards = args.dpo_beta * (policy_rejected - ref_rejected_for_metrics) + loss = pair_losses.sum() + if pair_losses.numel() == 0: + loss = loss + 0 * logits.sum() + return loss, { + "loss": pair_losses.detach().sum(), + "dpo_chosen_reward": chosen_rewards.detach().sum(), + "dpo_rejected_reward": rejected_rewards.detach().sum(), + "dpo_reward_margin": (chosen_rewards - rejected_rewards).detach().sum(), + "dpo_pair_accuracy": (chosen_rewards > rejected_rewards).to(torch.float32).detach().sum(), + } + + def sft_loss_function_chunked( args: Namespace, batch: RolloutBatch, @@ -1277,6 +1354,10 @@ def loss_function( dynamic_cp_rank=batch.get("dynamic_cp_rank", None), ) num_samples = len(batch["response_lengths"]) + if getattr(args, "loss_type", None) == "sft" and getattr(args, "sft_objective", "causal_lm") == "dpo": + if num_samples % 2 != 0: + raise ValueError("preference micro-batch contains an odd number of branches") + num_samples //= 2 sum_of_sample_mean = get_sum_of_sample_mean( batch["total_lengths"], @@ -1296,7 +1377,9 @@ def loss_function( case "value_loss": func = value_loss_function case "sft": - if getattr(args, "sft_chunked_logits", False) and lm_head_forward is not None: + if getattr(args, "sft_objective", "causal_lm") == "dpo": + func = dpo_loss_function + elif getattr(args, "sft_chunked_logits", False) and lm_head_forward is not None: # Bind lm_head_forward so chunked path matches the standard # inner-func signature; outer body (recompute, CP guard, # Megatron scaling, return-tuple) is then shared with legacy. diff --git a/relax/components/actor.py b/relax/components/actor.py index 76768553a..e96aef501 100644 --- a/relax/components/actor.py +++ b/relax/components/actor.py @@ -14,7 +14,7 @@ from relax.components.base import Base from relax.distributed.coordination import PeerStepBarrier, RolloutOffloadBarrier from relax.distributed.ray.placement_group import allocate_train_group -from relax.engine.sft.runtime import is_sft_mode, sft_partition_id, sft_task_name +from relax.engine.sft.runtime import is_preference_mode, is_sft_mode, sft_partition_id, sft_task_name from relax.utils.async_utils import run from relax.utils.opd.opd_utils import set_managed_opd_teacher_on_train_group @@ -64,7 +64,11 @@ def __init__( self.actor_model.async_init( config, role=self.role, - with_ref=config.kl_coef != 0 or config.use_kl_loss, + with_ref=( + config.kl_coef != 0 + or config.use_kl_loss + or (is_preference_mode(config) and config.sft_objective == "dpo" and not config.dpo_reference_free) + ), with_opd_teacher=self.config.opd_teacher_load, ) ) diff --git a/relax/components/sft.py b/relax/components/sft.py index 4ae487d48..d6c611759 100644 --- a/relax/components/sft.py +++ b/relax/components/sft.py @@ -34,8 +34,14 @@ from transformers import AutoConfig, AutoTokenizer from relax.components.base import Base +from relax.engine.sft.dataset.preference import ( + PreferenceStreamingDataset, + ProcessedPreferencePair, + pack_preference_pairs_for_tq, +) from relax.engine.sft.dataset.streaming import ProcessedSample, SFTStreamingDataset, pack_samples_for_tq from relax.engine.sft.debug_print import print_first_sample +from relax.engine.sft.runtime import is_preference_mode from relax.utils.data.processor_pool import ProcessorPool from relax.utils.misc import load_function from relax.utils.training.eval_config import build_named_prompt_data_configs @@ -96,11 +102,12 @@ def _init_data_pipeline(self) -> None: if self._dataset is not None: return self._tokenizer = AutoTokenizer.from_pretrained(self.config.hf_checkpoint, trust_remote_code=True) - try: - self._processor_pool = ProcessorPool(self.config.hf_checkpoint, pool_size=None, trust_remote_code=True) - except Exception as exc: - self._logger.warning(f"Could not init ProcessorPool ({exc}); multimodal samples will fail at push.") - self._processor_pool = None + if not is_preference_mode(self.config): + try: + self._processor_pool = ProcessorPool(self.config.hf_checkpoint, pool_size=None, trust_remote_code=True) + except Exception as exc: + self._logger.warning(f"Could not init ProcessorPool ({exc}); multimodal samples will fail at push.") + self._processor_pool = None pad_token_ids = _resolve_pad_token_ids_from_config(self.config.hf_checkpoint) self._logger.info(f"Resolved multimodal pad token ids from model config: {sorted(pad_token_ids)}") @@ -123,7 +130,27 @@ def _init_data_pipeline(self) -> None: self._logger.info(f"SFT oversize strategy: {oversize_strategy}") dataset_cls = _load_custom_dataset_class(getattr(self.config, "custom_dataset_class_path", None)) - if dataset_cls is None: + if is_preference_mode(self.config): + self._dataset = PreferenceStreamingDataset( + path=self.config.prompt_data, + tokenizer=self._tokenizer, + prompt_key=self.config.input_key, + chosen_key=self.config.preference_chosen_key, + rejected_key=self.config.preference_rejected_key, + pair_id_key=self.config.preference_pair_id_key, + metadata_key=self.config.metadata_key, + max_length=self.config.preference_max_length, + max_completion_length=self.config.preference_max_completion_length, + pair_capacity=capacity, + seed=seed, + prefetch_max_cached=prefetch_buffer_size, + prefetch_chunk_size=prefetch_chunk_size, + prefetch_num_workers=prefetch_num_workers, + apply_chat_template_kwargs=getattr(self.config, "apply_chat_template_kwargs", None), + expected_chat_template_sha256=self.config.preference_chat_template_sha256, + require_no_generation_marker=self.config.preference_require_no_generation_marker, + ) + elif dataset_cls is None: self._dataset = SFTStreamingDataset( path=self.config.prompt_data, tokenizer=self._tokenizer, @@ -294,10 +321,16 @@ async def _wait_for_buffer_capacity(self) -> None: wait_count += 1 await asyncio.sleep(1) - def _maybe_print_first_sample(self, samples: list[ProcessedSample]) -> None: + def _maybe_print_first_sample(self, samples: list[ProcessedSample] | list[ProcessedPreferencePair]) -> None: if self.step != 0 or not samples: return s = samples[0] + if isinstance(s, ProcessedPreferencePair): + self._logger.info( + f"First preference pair: pair_id={s.pair_id!r}, " + f"chosen_length={s.chosen_total_length}, rejected_length={s.rejected_total_length}" + ) + return try: print_first_sample( step=self.step, @@ -325,12 +358,23 @@ async def _produce_one_step(self) -> None: self.step += 1 return self._maybe_print_first_sample(samples) - backend_batch = pack_samples_for_tq(samples, force_multimodal_field=self.config.multimodal_keys is not None) - assert backend_batch is not None - await self.data_system_client.async_put( - data=dict_to_tensordict(backend_batch, batch_size=len(backend_batch["tokens"])), - partition_id=f"sft_{self.step}", - ) + if is_preference_mode(self.config): + backend_batch, custom_meta = pack_preference_pairs_for_tq(samples) + batch_size = len(backend_batch["pair_ids"]) + await self.data_system_client.async_put( + data=dict_to_tensordict(backend_batch, batch_size=batch_size), + partition_id=f"sft_{self.step}", + custom_meta=custom_meta, + ) + else: + backend_batch = pack_samples_for_tq( + samples, force_multimodal_field=self.config.multimodal_keys is not None + ) + assert backend_batch is not None + await self.data_system_client.async_put( + data=dict_to_tensordict(backend_batch, batch_size=len(backend_batch["tokens"])), + partition_id=f"sft_{self.step}", + ) if crossed_epoch: self._logger.info( f"SFT step {self.step}: epoch boundary crossed (epoch={self._dataset.index_manager.current_epoch})" diff --git a/relax/engine/sft/bootstrap.py b/relax/engine/sft/bootstrap.py index 5871bde28..b22c7e55e 100644 --- a/relax/engine/sft/bootstrap.py +++ b/relax/engine/sft/bootstrap.py @@ -58,11 +58,21 @@ def resolve_sft_num_rollout(config: Namespace) -> None: # Lazy import: pulling streaming dataset at module load would drag heavy # multimodal deps into every controller import. - from relax.engine.sft.dataset.streaming import SFTStreamingDataset + if getattr(config, "sft_objective", "causal_lm") == "dpo": + from relax.engine.sft.dataset.preference import PreferenceStreamingDataset + + sizing_dataset = PreferenceStreamingDataset( + path=config.prompt_data, + pair_id_key=config.preference_pair_id_key, + prefetch_max_cached=0, + ) + else: + from relax.engine.sft.dataset.streaming import SFTStreamingDataset + + sizing_dataset = SFTStreamingDataset(path=config.prompt_data, prefetch_max_cached=0) # Sized-only construction: no tokenizer/processor needed because we never # call get_batch — we just need len() to derive num_rollout. - sizing_dataset = SFTStreamingDataset(path=config.prompt_data, prefetch_max_cached=0) dataset_size = len(sizing_dataset) num_per_epoch = dataset_size // config.rollout_batch_size assert num_per_epoch > 0, f"SFT dataset size {dataset_size} < rollout_batch_size {config.rollout_batch_size}" diff --git a/relax/engine/sft/dataset/preference.py b/relax/engine/sft/dataset/preference.py new file mode 100644 index 000000000..995e0450b --- /dev/null +++ b/relax/engine/sft/dataset/preference.py @@ -0,0 +1,421 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Streaming chosen/rejected dataset for offline preference objectives.""" + +import hashlib +import threading +from dataclasses import dataclass +from typing import Any + +import torch + +from relax.engine.sft.dataset.chat_template import ( + HAS_GENERATION_MARKER, + _resolve_sft_template_kwargs, + render_with_loss_mask, +) +from relax.engine.sft.dataset.sample import CanonicalMessage, CanonicalSample +from relax.engine.sft.dataset.streaming import _build_reader +from relax.utils.data.streaming_dataset import IndexManager, PrefetchBuffer +from relax.utils.logging_utils import get_logger + + +logger = get_logger(__name__) + + +@dataclass(frozen=True) +class PreferencePair: + """Canonical text-only preference pair before tokenization.""" + + pair_id: str + prompt: list[CanonicalMessage] + chosen: CanonicalMessage + rejected: CanonicalMessage + metadata: dict[str, Any] + + +@dataclass(frozen=True) +class ProcessedPreferencePair: + """Tokenized pair kept atomic until after DP assignment.""" + + pair_id: str + chosen_tokens: torch.Tensor + rejected_tokens: torch.Tensor + chosen_loss_mask: torch.Tensor + rejected_loss_mask: torch.Tensor + chosen_total_length: int + rejected_total_length: int + chosen_prompt_length: int + rejected_prompt_length: int + chosen_completion_length: int + rejected_completion_length: int + source_idx: int + + @property + def pair_total_length(self) -> int: + return self.chosen_total_length + self.rejected_total_length + + +def _message_from_raw(raw: Any, *, learn: bool, field: str) -> CanonicalMessage: + if not isinstance(raw, dict): + raise ValueError(f"preference {field} must be a message object") + role = raw.get("role") + content = raw.get("content") + if role is None or content is None: + raise ValueError(f"preference {field} message requires role and content") + if not isinstance(content, str): + raise ValueError(f"preference {field} must be pure text") + return CanonicalMessage(role=role, content=content, learn=learn, tool_calls=raw.get("tool_calls")) + + +def _normalize_pair_row( + row: dict[str, Any], + *, + row_index: int, + prompt_key: str, + chosen_key: str, + rejected_key: str, + pair_id_key: str, + metadata_key: str, + source_name: str, +) -> PreferencePair: + pair_id = row.get(pair_id_key) + if not isinstance(pair_id, str) or not pair_id: + raise ValueError(f"preference row requires a non-empty {pair_id_key}") + chosen_raw = row.get(chosen_key) + rejected_raw = row.get(rejected_key) + prompt_raw = row.get(prompt_key) + + if prompt_raw is None: + if not isinstance(chosen_raw, list) or not isinstance(rejected_raw, list): + raise ValueError("implicit preference rows require chosen/rejected message lists") + prefix_length = 0 + for chosen_message, rejected_message in zip(chosen_raw, rejected_raw, strict=False): + if chosen_message != rejected_message: + break + prefix_length += 1 + chosen_suffix = chosen_raw[prefix_length:] + rejected_suffix = rejected_raw[prefix_length:] + if len(chosen_suffix) != 1 or len(rejected_suffix) != 1: + raise ValueError("implicit preference rows require one assistant message after the strict common prefix") + prompt_raw = chosen_raw[:prefix_length] + chosen_raw = chosen_suffix[0] + rejected_raw = rejected_suffix[0] + elif not isinstance(prompt_raw, list): + raise ValueError(f"preference {prompt_key} must be a message list") + + prompt = [_message_from_raw(message, learn=False, field=prompt_key) for message in prompt_raw] + chosen = _message_from_raw(chosen_raw, learn=True, field=chosen_key) + rejected = _message_from_raw(rejected_raw, learn=True, field=rejected_key) + if chosen.role != "assistant" or rejected.role != "assistant": + raise ValueError("preference chosen/rejected messages must have role assistant") + if chosen.content == rejected.content: + raise ValueError("preference chosen/rejected responses must not be identical") + + metadata = row.get(metadata_key) or {} + if not isinstance(metadata, dict): + raise ValueError(f"preference {metadata_key} must be an object") + metadata = dict(metadata) + metadata.update({"source_dataset": source_name, "row_index": row_index, "pair_id": pair_id}) + return PreferencePair(pair_id=pair_id, prompt=prompt, chosen=chosen, rejected=rejected, metadata=metadata) + + +def _split_branch( + tokens: torch.Tensor, mask: torch.Tensor, *, pair_id: str, branch: str +) -> tuple[torch.Tensor, torch.Tensor]: + if tokens.ndim != 1 or mask.ndim != 1 or tokens.shape != mask.shape: + raise ValueError(f"preference pair {pair_id!r} {branch} tokens/mask must be aligned one-dimensional tensors") + supervised = torch.nonzero(mask, as_tuple=False).flatten() + if supervised.numel() == 0: + raise ValueError(f"preference pair {pair_id!r} {branch} completion has no supervised tokens") + first = int(supervised[0]) + if not bool(mask[first:].to(dtype=torch.bool).all()): + raise ValueError(f"preference pair {pair_id!r} {branch} completion mask must be one contiguous suffix") + return tokens[:first], tokens[first:] + + +def _truncate_pair( + prompt: torch.Tensor, + chosen_completion: torch.Tensor, + rejected_completion: torch.Tensor, + *, + pair_id: str, + max_length: int, + max_completion_length: int, + pair_capacity: int, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + chosen_completion = chosen_completion[:max_completion_length] + rejected_completion = rejected_completion[:max_completion_length] + if chosen_completion.numel() == 0 or rejected_completion.numel() == 0: + raise ValueError(f"preference pair {pair_id!r} has an empty completion after truncation") + prompt_budget = max_length - max(chosen_completion.numel(), rejected_completion.numel()) + if prompt_budget < 0: + raise ValueError(f"preference pair {pair_id!r} completion exceeds max_length={max_length}") + prompt = prompt[-prompt_budget:] if prompt_budget else prompt[:0] + + def total() -> int: + return 2 * prompt.numel() + chosen_completion.numel() + rejected_completion.numel() + + while total() > pair_capacity: + if chosen_completion.numel() >= rejected_completion.numel() and chosen_completion.numel() > 1: + chosen_completion = chosen_completion[:-1] + elif rejected_completion.numel() > 1: + rejected_completion = rejected_completion[:-1] + elif prompt.numel() > 0: + prompt = prompt[1:] + else: + raise ValueError( + f"preference pair {pair_id!r} cannot fit pair capacity {pair_capacity} while retaining both completions" + ) + return prompt.contiguous(), chosen_completion.contiguous(), rejected_completion.contiguous() + + +class PreferenceStreamingDataset: + """Lazy text-only preference dataset with deterministic epoch shuffling.""" + + def __init__( + self, + path: str | list[str] | tuple[str, ...], + *, + tokenizer=None, + prompt_key: str = "prompt", + chosen_key: str = "chosen", + rejected_key: str = "rejected", + pair_id_key: str = "prompt_id", + metadata_key: str = "metadata", + source_name: str = "preference_data", + max_length: int = 1024, + max_completion_length: int = 512, + pair_capacity: int | None = None, + seed: int = 42, + prefetch_max_cached: int = 256, + prefetch_chunk_size: int = 32, + prefetch_num_workers: int = 4, + apply_chat_template_kwargs: dict | None = None, + expected_chat_template_sha256: str | None = None, + require_no_generation_marker: bool = False, + ) -> None: + if max_length <= 0 or max_completion_length <= 0: + raise ValueError("preference length limits must be positive") + self.reader = _build_reader(path) + self.index_manager = IndexManager(len(self.reader), seed=seed) + self.tokenizer = tokenizer + self.prompt_key = prompt_key + self.chosen_key = chosen_key + self.rejected_key = rejected_key + self.pair_id_key = pair_id_key + self.metadata_key = metadata_key + self.source_name = source_name + self.max_length = max_length + self.max_completion_length = max_completion_length + self.pair_capacity = pair_capacity or (2 * max_length) + self.apply_chat_template_kwargs = apply_chat_template_kwargs + self.expected_chat_template_sha256 = expected_chat_template_sha256 + self.require_no_generation_marker = require_no_generation_marker + self._template_contract_validated = False + self._template_contract_lock = threading.Lock() + self._validate_unique_pair_ids() + self._first_error: BaseException | None = None + self._error_lock = threading.Lock() + self._prefetch: PrefetchBuffer | None = None + if prefetch_max_cached > 0: + self._prefetch = PrefetchBuffer( + process_fn=self._process_one_safe, + chunk_size=prefetch_chunk_size, + max_cached=prefetch_max_cached, + num_workers=prefetch_num_workers, + ) + + def __len__(self) -> int: + return len(self.reader) + + def _validate_unique_pair_ids(self) -> None: + seen: set[str] = set() + for index in range(len(self.reader)): + pair_id = self.reader[index].get(self.pair_id_key) + if not isinstance(pair_id, str) or not pair_id: + raise ValueError(f"preference row {index} requires a non-empty {self.pair_id_key}") + if pair_id in seen: + raise ValueError(f"duplicate preference pair ID {pair_id!r} at row {index}") + seen.add(pair_id) + + def shuffle(self, epoch_id: int, position: int = 0) -> None: + self.index_manager.shuffle(epoch_id) + if position: + self.index_manager.position = min(position, self.index_manager.total_size) + if self._prefetch is not None and self.index_manager.indices is not None: + remaining = self.index_manager.indices[self.index_manager.position :] + self._prefetch.set_index_order(list(remaining)) + + def stop(self) -> None: + if self._prefetch is not None: + self._prefetch.stop() + + def get_canonical_pair(self, idx: int) -> PreferencePair: + return _normalize_pair_row( + self.reader[idx], + row_index=idx, + prompt_key=self.prompt_key, + chosen_key=self.chosen_key, + rejected_key=self.rejected_key, + pair_id_key=self.pair_id_key, + metadata_key=self.metadata_key, + source_name=self.source_name, + ) + + def get_processed_pair(self, idx: int) -> ProcessedPreferencePair: + if self.tokenizer is None: + raise RuntimeError("PreferenceStreamingDataset requires a tokenizer for processing") + pair = self.get_canonical_pair(idx) + chosen_sample = CanonicalSample(messages=[*pair.prompt, pair.chosen], metadata=dict(pair.metadata), tools=None) + rejected_sample = CanonicalSample( + messages=[*pair.prompt, pair.rejected], metadata=dict(pair.metadata), tools=None + ) + self._validate_template_contract(chosen_sample) + chosen_tokens, chosen_mask = render_with_loss_mask( + chosen_sample, + tokenizer=self.tokenizer, + apply_chat_template_kwargs=self.apply_chat_template_kwargs, + ) + rejected_tokens, rejected_mask = render_with_loss_mask( + rejected_sample, + tokenizer=self.tokenizer, + apply_chat_template_kwargs=self.apply_chat_template_kwargs, + ) + chosen_prompt, chosen_completion = _split_branch( + chosen_tokens, chosen_mask, pair_id=pair.pair_id, branch="chosen" + ) + rejected_prompt, rejected_completion = _split_branch( + rejected_tokens, rejected_mask, pair_id=pair.pair_id, branch="rejected" + ) + if not torch.equal(chosen_prompt, rejected_prompt): + raise ValueError(f"preference pair {pair.pair_id!r} chosen/rejected prompt tokens differ") + prompt, chosen_completion, rejected_completion = _truncate_pair( + chosen_prompt, + chosen_completion, + rejected_completion, + pair_id=pair.pair_id, + max_length=self.max_length, + max_completion_length=self.max_completion_length, + pair_capacity=self.pair_capacity, + ) + chosen_tokens = torch.cat((prompt, chosen_completion)) + rejected_tokens = torch.cat((prompt, rejected_completion)) + if torch.equal(chosen_tokens, rejected_tokens) or torch.equal(chosen_completion, rejected_completion): + raise ValueError(f"preference pair {pair.pair_id!r} is post-truncation identical") + chosen_mask = torch.cat((torch.zeros_like(prompt), torch.ones_like(chosen_completion))) + rejected_mask = torch.cat((torch.zeros_like(prompt), torch.ones_like(rejected_completion))) + return ProcessedPreferencePair( + pair_id=pair.pair_id, + chosen_tokens=chosen_tokens, + rejected_tokens=rejected_tokens, + chosen_loss_mask=chosen_mask, + rejected_loss_mask=rejected_mask, + chosen_total_length=chosen_tokens.numel(), + rejected_total_length=rejected_tokens.numel(), + chosen_prompt_length=prompt.numel(), + rejected_prompt_length=prompt.numel(), + chosen_completion_length=chosen_completion.numel(), + rejected_completion_length=rejected_completion.numel(), + source_idx=idx, + ) + + def _validate_template_contract(self, sample: CanonicalSample) -> None: + if self._template_contract_validated: + return + with self._template_contract_lock: + if self._template_contract_validated: + return + resolved = _resolve_sft_template_kwargs( + sample, + tokenizer=self.tokenizer, + apply_chat_template_kwargs=self.apply_chat_template_kwargs, + ) + template = resolved.template or "" + digest = hashlib.sha256(template.encode()).hexdigest() + if self.expected_chat_template_sha256 is not None and digest != self.expected_chat_template_sha256: + raise ValueError( + "preference chat template SHA-256 mismatch: " + f"expected={self.expected_chat_template_sha256}, actual={digest}" + ) + if self.require_no_generation_marker and HAS_GENERATION_MARKER(template): + raise ValueError("preference recipe requires a chat template without {% generation %} markers") + self._template_contract_validated = True + + def _process_one_safe(self, idx: int) -> ProcessedPreferencePair | None: + try: + return self.get_processed_pair(idx) + except Exception as exc: + with self._error_lock: + if self._first_error is None: + self._first_error = exc + logger.exception(f"PreferenceStreamingDataset: failed to process pair idx={idx}") + return None + + def _raise_if_failed(self) -> None: + with self._error_lock: + error = self._first_error + if error is not None: + raise error + + def get_batch(self, n: int) -> tuple[list[ProcessedPreferencePair], bool]: + if n <= 0: + raise ValueError(f"batch size must be positive, got {n}") + self._raise_if_failed() + pairs: list[ProcessedPreferencePair] = [] + crossed_epoch = False + attempts = 0 + max_attempts = max(n * 10, 32) + while len(pairs) < n and attempts < max_attempts: + indices, crossed = self.index_manager.get_next_indices(1) + crossed_epoch = crossed_epoch or crossed + attempts += 1 + index = indices[0] + pair = self._prefetch.get(index) if self._prefetch is not None else self.get_processed_pair(index) + if pair is None: + self._raise_if_failed() + else: + pairs.append(pair) + if len(pairs) != n: + raise RuntimeError(f"preference dataset returned a partial batch: expected {n}, got {len(pairs)}") + return pairs, crossed_epoch + + async def get_batch_async(self, n: int) -> tuple[list[ProcessedPreferencePair], bool]: + return self.get_batch(n) + + def get_batch_in_order(self, start: int, n: int) -> list[ProcessedPreferencePair]: + return [self.get_processed_pair(index) for index in range(start, min(start + n, len(self.reader)))] + + +def pack_preference_pairs_for_tq( + pairs: list[ProcessedPreferencePair], +) -> tuple[dict[str, list[Any]], list[dict[str, int]]]: + """Pack atomic pair rows and matching TransferQueue length metadata.""" + if not pairs: + raise ValueError("preference pair batch must not be empty") + encoded_pair_ids = [ + int.from_bytes(hashlib.sha256(pair.pair_id.encode()).digest()[:8], "big") >> 1 for pair in pairs + ] + if len(set(encoded_pair_ids)) != len(encoded_pair_ids): + raise ValueError("preference pair ID hash collision within batch") + batch: dict[str, list[Any]] = { + "pair_ids": encoded_pair_ids, + "chosen_tokens": [pair.chosen_tokens.tolist() for pair in pairs], + "rejected_tokens": [pair.rejected_tokens.tolist() for pair in pairs], + "chosen_loss_masks": [pair.chosen_loss_mask.tolist() for pair in pairs], + "rejected_loss_masks": [pair.rejected_loss_mask.tolist() for pair in pairs], + "chosen_total_lengths": [pair.chosen_total_length for pair in pairs], + "rejected_total_lengths": [pair.rejected_total_length for pair in pairs], + } + custom_meta = [{"total_lengths": pair.pair_total_length} for pair in pairs] + if len(custom_meta) != len(pairs): + raise RuntimeError("preference custom metadata is not row-aligned") + return batch, custom_meta + + +__all__ = [ + "PreferencePair", + "PreferenceStreamingDataset", + "ProcessedPreferencePair", + "pack_preference_pairs_for_tq", +] diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index d5c1a51cc..1b3a68d45 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -7,6 +7,7 @@ here keeps the dispatchers in those files to one-line calls. """ +import math from argparse import Namespace @@ -19,6 +20,72 @@ def is_sft_mode(args: Namespace) -> bool: return getattr(args, "loss_type", None) == "sft" +def sft_objective(args: Namespace) -> str: + """Return the offline objective while preserving causal-LM defaults.""" + return getattr(args, "sft_objective", "causal_lm") + + +def is_preference_mode(args: Namespace) -> bool: + return is_sft_mode(args) and sft_objective(args) == "dpo" + + +def validate_preference_args(args: Namespace) -> None: + """Reject unsupported preference configurations before Serve starts.""" + if not is_preference_mode(args): + return + if getattr(args, "custom_dataset_class_path", None): + raise ValueError("preference objectives do not support --custom-dataset-class") + if getattr(args, "multimodal_keys", None) is not None: + raise ValueError("preference objectives v1 support pure text only") + if int(getattr(args, "n_samples_per_prompt", 1)) != 1: + raise ValueError("preference objectives require --n-samples-per-prompt 1") + topology = { + "tensor_model_parallel_size": int(getattr(args, "tensor_model_parallel_size", 1) or 1), + "pipeline_model_parallel_size": int(getattr(args, "pipeline_model_parallel_size", 1) or 1), + "context_parallel_size": int(getattr(args, "context_parallel_size", 1) or 1), + } + invalid = {name: size for name, size in topology.items() if size != 1} + if invalid: + raise ValueError(f"preference objectives v1 require TP=CP=PP=1, got {invalid}") + if getattr(args, "dynamic_context_parallel", False): + raise ValueError("preference objectives v1 do not support dynamic context parallelism") + if getattr(args, "qkv_format", "thd") != "thd": + raise ValueError("preference objectives v1 require --qkv-format thd") + if getattr(args, "fully_async", False) or getattr(args, "hybrid", False): + raise ValueError("preference objectives v1 support synchronous SFT topology only") + if getattr(args, "sft_chunked_logits", False) or getattr(args, "enable_mtp_training", False): + raise ValueError("preference objectives v1 do not support SFT chunked logits or MTP") + if getattr(args, "calculate_per_token_loss", False): + raise ValueError("preference objectives use pair reduction and reject --calculate-per-token-loss") + if int(getattr(args, "lora_rank", 0) or 0) > 0: + raise ValueError("preference objectives v1 do not support LoRA") + if ( + float(getattr(args, "hidden_dropout", 0.0) or 0.0) != 0.0 + or float(getattr(args, "attention_dropout", 0.0) or 0.0) != 0.0 + ): + raise ValueError("preference objectives require hidden and attention dropout to be 0.0") + if getattr(args, "sft_predict_interval", None) is not None: + raise ValueError("preference objectives do not use SFT generation prediction") + max_length = int(getattr(args, "preference_max_length", 0) or 0) + max_completion_length = int(getattr(args, "preference_max_completion_length", 0) or 0) + if max_length <= 0 or max_completion_length <= 0: + raise ValueError("preference length limits must be positive") + if max_completion_length > max_length: + raise ValueError("--preference-max-completion-length must not exceed --preference-max-length") + seq_length = int(getattr(args, "seq_length", max_length) or max_length) + if max_length > seq_length: + raise ValueError("--preference-max-length must not exceed --seq-length") + if bool(getattr(args, "eval_prompt_data", None)) or getattr(args, "eval_size", None) is not None: + raise ValueError("DPO held-out evaluation is delivered by the follow-up reward-modeling PR") + beta = float(getattr(args, "dpo_beta", 0.1)) + if not math.isfinite(beta) or beta <= 0: + raise ValueError(f"--dpo-beta must be finite and positive, got {beta}") + if not getattr(args, "dpo_reference_free", False) and getattr(args, "ref_update_interval", None) is not None: + raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") + if not getattr(args, "dpo_reference_free", False) and not getattr(args, "enable_weights_backuper", False): + raise ValueError("standard DPO requires --enable-weights-backuper for actor/ref snapshots") + + def sft_partition_id(args: Namespace, step: int) -> str: return f"sft_{step}" if is_sft_mode(args) else f"train_{step}" diff --git a/relax/utils/arguments.py b/relax/utils/arguments.py index b3042b039..10af0fc52 100644 --- a/relax/utils/arguments.py +++ b/relax/utils/arguments.py @@ -463,6 +463,26 @@ def add_train_arguments(parser): ) # ---- SFT / Predict ---- + parser.add_argument( + "--sft-objective", + choices=["causal_lm", "dpo"], + default="causal_lm", + help="Offline objective under --loss-type sft. Defaults to the existing causal-LM behavior.", + ) + parser.add_argument("--preference-chosen-key", type=str, default="chosen") + parser.add_argument("--preference-rejected-key", type=str, default="rejected") + parser.add_argument("--preference-pair-id-key", type=str, default="prompt_id") + parser.add_argument("--preference-max-length", type=int, default=1024) + parser.add_argument("--preference-max-completion-length", type=int, default=512) + parser.add_argument("--preference-chat-template-sha256", type=str, default=None) + parser.add_argument("--preference-require-no-generation-marker", action="store_true", default=False) + parser.add_argument("--dpo-beta", type=float, default=0.1) + parser.add_argument( + "--dpo-reference-free", + action=argparse.BooleanOptionalAction, + default=False, + help="Use explicit reference-free logistic DPO instead of a frozen reference checkpoint.", + ) parser.add_argument( "--custom-dataset-class", "--custom-dataset-class-path", @@ -2869,6 +2889,9 @@ def slime_validate_args(args): if not args.balance_data: logger.info("--loss-type sft: auto-enabling --balance-data for DP-balanced batching.") args.balance_data = True + from relax.engine.sft.runtime import validate_preference_args + + validate_preference_args(args) args.use_critic = args.advantage_estimator == "ppo" # Synchronous PPO has no producer for diff --git a/relax/utils/data/stream_dataloader.py b/relax/utils/data/stream_dataloader.py index bc2c11e2e..919c762b2 100644 --- a/relax/utils/data/stream_dataloader.py +++ b/relax/utils/data/stream_dataloader.py @@ -876,6 +876,15 @@ def get_data_from_transfer_queue( def post_process_rollout_data(args, rollout_data): # move tokens/loss_masks to GPU in-place as a list of tensors (downstream # code in this module expects lists of sequence tensors for packing) + if "tokens" not in rollout_data and "chosen_tokens" in rollout_data: + # Preference rows stay pair-atomic in TransferQueue. Expand them only + # after sampling, before the generic sequence post-processing below. + from relax.backends.megatron.data import expand_preference_rollout_data + + expanded = expand_preference_rollout_data(rollout_data) + rollout_data.clear() + rollout_data.update(expanded) + from relax.backends.megatron.cp_utils import maybe_padded_total_lengths, slice_log_prob_with_cp cuda_dev = device_utils.make_current_torch_device() diff --git a/relax/utils/training/data_fields.py b/relax/utils/training/data_fields.py index ebd6479af..101a5d7ba 100644 --- a/relax/utils/training/data_fields.py +++ b/relax/utils/training/data_fields.py @@ -27,6 +27,16 @@ def build_data_fields(args: Namespace, *, consumer: str = "actor") -> list[str]: ``actor``); other algorithms ignore it and receive the base rollout fields. """ if getattr(args, "loss_type", None) == "sft": + if getattr(args, "sft_objective", "causal_lm") == "dpo": + return [ + "pair_ids", + "chosen_tokens", + "rejected_tokens", + "chosen_loss_masks", + "rejected_loss_masks", + "chosen_total_lengths", + "rejected_total_lengths", + ] fields = ["tokens", "total_lengths", "response_lengths", "loss_masks"] if args.multimodal_keys is not None: fields.append("multimodal_train_inputs") diff --git a/relax/utils/training/preference_utils.py b/relax/utils/training/preference_utils.py new file mode 100644 index 000000000..3df23f89b --- /dev/null +++ b/relax/utils/training/preference_utils.py @@ -0,0 +1,112 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Pure helpers for pair-aware DPO training.""" + +from collections.abc import Sequence + +import torch +import torch.nn.functional as F + + +def _validate_same_shape(name: str, *values: torch.Tensor) -> None: + if not values: + raise ValueError(f"{name} requires at least one tensor") + expected = values[0].shape + if any(value.shape != expected for value in values[1:]): + shapes = [tuple(value.shape) for value in values] + raise ValueError(f"{name} tensors must have identical shapes, got {shapes}") + if any(not torch.isfinite(value).all() for value in values): + raise ValueError(f"{name} tensors must contain only finite values") + + +def build_causal_lm_labels(tokens: torch.Tensor, raw_loss_mask: torch.Tensor) -> torch.Tensor: + """Build next-token labels from an unshifted completion-token mask.""" + if tokens.ndim != 1 or raw_loss_mask.ndim != 1: + raise ValueError("tokens and raw_loss_mask must be one-dimensional") + if tokens.shape != raw_loss_mask.shape: + raise ValueError(f"tokens/raw_loss_mask shape mismatch: {tuple(tokens.shape)} vs {tuple(raw_loss_mask.shape)}") + labels = torch.full_like(tokens, -100) + if tokens.numel() > 1: + supervised = raw_loss_mask[1:].to(dtype=torch.bool) + labels[:-1][supervised] = tokens[1:][supervised] + return labels + + +def dpo_pair_loss( + policy_chosen: torch.Tensor, + policy_rejected: torch.Tensor, + *, + reference_chosen: torch.Tensor | None = None, + reference_rejected: torch.Tensor | None = None, + beta: float = 0.1, + reference_free: bool = False, +) -> torch.Tensor: + """Return unreduced sigmoid-DPO loss, one value per preference pair.""" + if beta <= 0: + raise ValueError(f"DPO beta must be positive, got {beta}") + _validate_same_shape("policy log-probabilities", policy_chosen, policy_rejected) + policy_logratio = policy_chosen - policy_rejected + if reference_free: + if reference_chosen is not None or reference_rejected is not None: + raise ValueError("reference-free DPO must not receive reference log-probabilities") + reference_logratio = torch.zeros_like(policy_logratio) + else: + if reference_chosen is None or reference_rejected is None: + raise ValueError("standard DPO requires chosen and rejected reference log-probabilities") + _validate_same_shape( + "reference log-probabilities", + policy_chosen, + reference_chosen, + reference_rejected, + ) + reference_logratio = reference_chosen - reference_rejected + logits = beta * (policy_logratio - reference_logratio) + if not torch.isfinite(logits).all(): + raise ValueError("DPO logits must contain only finite values") + return -F.logsigmoid(logits) + + +def pack_preference_pair_indices( + costs: Sequence[int], + pair_ids: Sequence[str], + *, + capacity: int, +) -> list[list[int]]: + """Deterministic capacity-aware first-fit-decreasing pair packing.""" + if capacity <= 0: + raise ValueError(f"capacity must be positive, got {capacity}") + if len(costs) != len(pair_ids): + raise ValueError(f"costs/pair_ids length mismatch: {len(costs)} vs {len(pair_ids)}") + normalized_costs = [int(cost) for cost in costs] + for pair_id, cost in zip(pair_ids, normalized_costs, strict=True): + if cost <= 0: + raise ValueError(f"pair {pair_id!r} has non-positive cost {cost}") + if cost > capacity: + raise ValueError(f"oversize preference pair {pair_id!r} has cost {cost}, capacity={capacity}") + + order = sorted(range(len(normalized_costs)), key=lambda index: (-normalized_costs[index], str(pair_ids[index]))) + bins: list[list[int]] = [] + bin_costs: list[int] = [] + for index in order: + cost = normalized_costs[index] + for bin_index, bin_cost in enumerate(bin_costs): + if bin_cost + cost <= capacity: + bins[bin_index].append(index) + bin_costs[bin_index] += cost + break + else: + bins.append([index]) + bin_costs.append(cost) + + if sorted(index for group in bins for index in group) != list(range(len(normalized_costs))): + raise RuntimeError("preference pair packer lost or duplicated pair indices") + if any(sum(normalized_costs[index] for index in group) > capacity for group in bins): + raise RuntimeError("preference pair packer produced an over-capacity micro-batch") + return bins + + +__all__ = [ + "build_causal_lm_labels", + "dpo_pair_loss", + "pack_preference_pair_indices", +] diff --git a/scripts/data/prepare_ultrafeedback_preferences.py b/scripts/data/prepare_ultrafeedback_preferences.py new file mode 100644 index 000000000..32dafd0c2 --- /dev/null +++ b/scripts/data/prepare_ultrafeedback_preferences.py @@ -0,0 +1,159 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Create deterministic Task 31 train/eval preference subsets and a provenance +manifest.""" + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Any + + +DATASET_ID = "HuggingFaceH4/ultrafeedback_binarized" +DATASET_REVISION = "3949bf5f8c17c394422ccfab0c31ea9c20bdeb85" +ORDER_NAMESPACE = "task31-ultrafeedback-v1:" + + +def _sha256(path: Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as stream: + for chunk in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _validate_row(row: dict[str, Any], *, split: str, index: int) -> str: + prompt_id = row.get("prompt_id") + if not isinstance(prompt_id, str) or not prompt_id: + raise ValueError(f"{split}[{index}] has no non-empty prompt_id") + chosen = row.get("chosen") + rejected = row.get("rejected") + if not isinstance(chosen, list) or not isinstance(rejected, list) or not chosen or not rejected: + raise ValueError(f"{split}[{index}] {prompt_id} has invalid chosen/rejected messages") + if chosen == rejected: + raise ValueError(f"{split}[{index}] {prompt_id} has identical chosen/rejected branches") + if chosen[-1].get("role") != "assistant" or rejected[-1].get("role") != "assistant": + raise ValueError(f"{split}[{index}] {prompt_id} must end both branches with assistant") + if chosen[:-1] != rejected[:-1]: + raise ValueError(f"{split}[{index}] {prompt_id} does not have a strict shared prompt") + return prompt_id + + +def _select(dataset, *, split: str, count: int) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: + seen: set[str] = set() + candidates: list[tuple[str, str, dict[str, Any]]] = [] + rejected: list[dict[str, Any]] = [] + for index, row in enumerate(dataset): + prompt_id = row.get("prompt_id") + if not isinstance(prompt_id, str) or not prompt_id: + raise ValueError(f"{split}[{index}] has no non-empty prompt_id") + if prompt_id in seen: + rejected.append( + { + "prompt_id": prompt_id, + "source_index": index, + "reason": f"duplicate prompt_id in {split}; retained first source occurrence", + } + ) + continue + seen.add(prompt_id) + order_key = hashlib.sha256(f"{ORDER_NAMESPACE}{prompt_id}".encode()).hexdigest() + candidates.append((order_key, prompt_id, {**row, "_source_index": index})) + if len(candidates) < count: + raise ValueError(f"{split} contains {len(candidates)} valid rows, need {count}") + candidates.sort(key=lambda item: (item[0], item[1])) + selected: list[dict[str, Any]] = [] + for _, prompt_id, row in candidates: + source_index = row.pop("_source_index") + try: + _validate_row(row, split=split, index=source_index) + except ValueError as exc: + rejected.append({"prompt_id": prompt_id, "source_index": source_index, "reason": str(exc)}) + continue + selected.append( + { + "prompt_id": prompt_id, + "chosen": row["chosen"], + "rejected": row["rejected"], + "metadata": { + "source_split": split, + "score_chosen": row.get("score_chosen"), + "score_rejected": row.get("score_rejected"), + }, + } + ) + if len(selected) == count: + break + if len(selected) != count: + raise ValueError(f"{split} contains only {len(selected)} valid rows after deterministic validation") + return selected, rejected + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + with path.open("w", encoding="utf-8", newline="\n") as stream: + for row in rows: + stream.write(json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n") + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--output-dir", type=Path, required=True) + parser.add_argument("--train-size", type=int, default=4096) + parser.add_argument("--eval-size", type=int, default=512) + args = parser.parse_args() + if args.train_size <= 0 or args.eval_size <= 0: + parser.error("subset sizes must be positive") + + from datasets import Dataset, load_dataset + + train_source = load_dataset(DATASET_ID, revision=DATASET_REVISION, split="train_prefs") + eval_source = load_dataset(DATASET_ID, revision=DATASET_REVISION, split="test_prefs") + train_rows, train_rejections = _select(train_source, split="train_prefs", count=args.train_size) + eval_rows, eval_rejections = _select(eval_source, split="test_prefs", count=args.eval_size) + train_ids = {row["prompt_id"] for row in train_rows} + eval_ids = {row["prompt_id"] for row in eval_rows} + overlap = train_ids & eval_ids + if overlap: + raise ValueError(f"train/eval prompt_id overlap: {sorted(overlap)[:5]}") + + args.output_dir.mkdir(parents=True, exist_ok=True) + outputs: dict[str, dict[str, Any]] = {} + for name, rows in (("train", train_rows), ("eval", eval_rows)): + jsonl_path = args.output_dir / f"ultrafeedback_{name}.jsonl" + parquet_path = args.output_dir / f"ultrafeedback_{name}.parquet" + _write_jsonl(jsonl_path, rows) + Dataset.from_list(rows).to_parquet(parquet_path) + outputs[name] = { + "count": len(rows), + "prompt_ids": [row["prompt_id"] for row in rows], + "jsonl": {"path": jsonl_path.name, "sha256": _sha256(jsonl_path)}, + "parquet": {"path": parquet_path.name, "sha256": _sha256(parquet_path)}, + } + + manifest = { + "schema_version": 1, + "source": {"dataset": DATASET_ID, "revision": DATASET_REVISION}, + "selection": { + "algorithm": f'sha256("{ORDER_NAMESPACE}" + prompt_id), then first valid rows', + "overlap_count": 0, + "rejections": { + "train": train_rejections, + "eval": eval_rejections, + }, + }, + "schema": { + "prompt_id": "string", + "chosen": "list<{role:string,content:string}>", + "rejected": "list<{role:string,content:string}>", + "metadata": "object", + }, + "outputs": outputs, + } + manifest_path = args.output_dir / "manifest.json" + manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(json.dumps({"manifest": str(manifest_path), "sha256": _sha256(manifest_path)}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh new file mode 100644 index 000000000..f0cb38e01 --- /dev/null +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -0,0 +1,61 @@ +#!/bin/bash + +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +set -eo pipefail +set -x + +SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)" +if [ -z "${RELAX_ENTRYPOINT_MODE:-}" ]; then + source "${SCRIPT_DIR}/../../entrypoint/local.sh" +fi +source "${MODEL_CONFIG_DIR}/qwen3-0.6B.sh" + +MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +HF_CHECKPOINT="${HF_CHECKPOINT:-${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}}" +PROMPT_DATA="${PROMPT_DATA:?set PROMPT_DATA to the Task 31 train JSONL or Parquet}" +SAVE_DIR="${SAVE_DIR:-${SCRIPT_DIR}/../../../checkpoints/task31-dpo}" +EXP_NAME="${EXP_NAME:-qwen3-0.6b-ultrafeedback-dpo-gpu1}" +now=$(date "+%Y-%m-%d-%H:%M:%S") + +mkdir -p log "${SAVE_DIR}" +ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ + ${WORKING_DIR:+--working-dir "${WORKING_DIR}"} \ + --runtime-env-json="${RUNTIME_ENV_JSON}" \ + -- python3 -m relax.entrypoints.train \ + --resource '{"sft":[1,0],"actor":[1,1]}' \ + --loss-type sft \ + --sft-objective dpo \ + --dpo-beta 0.1 \ + --prompt-data "${PROMPT_DATA}" \ + --input-key prompt \ + --preference-pair-id-key prompt_id \ + --preference-max-length 1024 \ + --preference-max-completion-length 512 \ + --preference-chat-template-sha256 56965952fc78cd889bcd1864d70e85271861eef93385410b879c0c4c2d40564d \ + --preference-require-no-generation-marker \ + --hf-checkpoint "${HF_CHECKPOINT}" \ + --ref-load "${HF_CHECKPOINT}" \ + --megatron-to-hf-mode bridge \ + --save "${SAVE_DIR}/${EXP_NAME}" \ + --load "${SAVE_DIR}/${EXP_NAME}" \ + --save-interval 50 \ + --num-rollout "${NUM_ROLLOUT:-200}" \ + --global-batch-size "${GLOBAL_BATCH_SIZE:-8}" \ + --use-dynamic-batch-size \ + --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ + --tensor-model-parallel-size 1 \ + --pipeline-model-parallel-size 1 \ + --context-parallel-size 1 \ + --optimizer adam \ + --lr "${LR:-5e-7}" \ + --lr-decay-style cosine \ + --min-lr 0 \ + --weight-decay 0.0 \ + --clip-grad 1.0 \ + --attention-dropout 0.0 \ + --hidden-dropout 0.0 \ + --attention-backend flash \ + --no-rope-fusion \ + --colocate \ + "${MODEL_ARGS[@]}" 2>&1 | tee "log/${EXP_NAME}-${now}.log" diff --git a/tests/backends/megatron/test_sft_train_data_fields.py b/tests/backends/megatron/test_sft_train_data_fields.py index 21a58d111..79e00c2af 100644 --- a/tests/backends/megatron/test_sft_train_data_fields.py +++ b/tests/backends/megatron/test_sft_train_data_fields.py @@ -5,6 +5,8 @@ from argparse import Namespace +import torch + def _mk_actor_args(loss_type: str): return Namespace( @@ -41,6 +43,48 @@ def test_sft_data_fields_excludes_rl_only_keys(): assert forbidden not in fields, f"SFT data_fields leaked RL key: {forbidden}" +def test_preference_data_fields_keep_pairs_atomic(): + from relax.utils.training.data_fields import build_data_fields + + args = _mk_actor_args(loss_type="sft") + args.sft_objective = "dpo" + + fields = build_data_fields(args) + + assert fields == [ + "pair_ids", + "chosen_tokens", + "rejected_tokens", + "chosen_loss_masks", + "rejected_loss_masks", + "chosen_total_lengths", + "rejected_total_lengths", + ] + + +def test_preference_rows_expand_before_generic_rollout_post_processing(monkeypatch): + from relax.utils.data import stream_dataloader + + rollout_data = { + "pair_ids": [17], + "chosen_tokens": [[1, 2, 3]], + "rejected_tokens": [[1, 4]], + "chosen_loss_masks": [[0, 1, 1]], + "rejected_loss_masks": [[0, 1]], + "chosen_total_lengths": [3], + "rejected_total_lengths": [2], + } + args = Namespace(qkv_format="thd", is_vl_model=False, uses_unsplit_forward=False, use_opd=False) + monkeypatch.setattr(stream_dataloader.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) + + stream_dataloader.post_process_rollout_data(args, rollout_data) + + assert [tensor.tolist() for tensor in rollout_data["tokens"]] == [[1, 2, 3], [1, 4]] + assert [tensor.tolist() for tensor in rollout_data["loss_masks"]] == [[0, 1, 1], [0, 1]] + assert rollout_data["preference_pair_ids"] == [17] + assert rollout_data["preference_pair_costs"] == [5] + + def test_rl_data_fields_unchanged(): """RL path must keep the existing field set.""" from relax.utils.training.data_fields import build_data_fields diff --git a/tests/engine/sft/dataset/test_preference.py b/tests/engine/sft/dataset/test_preference.py new file mode 100644 index 000000000..6fc704aa4 --- /dev/null +++ b/tests/engine/sft/dataset/test_preference.py @@ -0,0 +1,198 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Preference-pair schema, rendering, truncation, and queue tests.""" + +import json +from pathlib import Path + +import pytest +import torch + +from relax.engine.sft.dataset.preference import PreferenceStreamingDataset, pack_preference_pairs_for_tq + + +def _write_jsonl(path: Path, rows: list[dict]) -> None: + with path.open("w") as file: + for row in rows: + file.write(json.dumps(row) + "\n") + + +class _FakeTokenizer: + chat_template = "{% generation %}assistant{% endgeneration %}" + + def apply_chat_template( + self, + messages, + *, + tools=None, # noqa: ARG002 + tokenize=True, # noqa: ARG002 + return_tensors=None, # noqa: ARG002 + return_dict=False, + return_assistant_tokens_mask=False, + **kwargs, # noqa: ARG002 + ): + ids: list[int] = [] + masks: list[int] = [] + for message in messages: + prefix = {"system": 10, "user": 20, "assistant": 30}[message["role"]] + content = message["content"] + encoded = [prefix + (ord(char) % 10) for char in content] + ids.extend(encoded) + masks.extend([int(message["role"] == "assistant")] * len(encoded)) + input_ids = torch.tensor([ids], dtype=torch.long) + if return_assistant_tokens_mask: + return {"input_ids": input_ids, "assistant_masks": [masks]} + return input_ids + + +def _dataset(path: Path, **kwargs) -> PreferenceStreamingDataset: + return PreferenceStreamingDataset( + path=str(path), + tokenizer=_FakeTokenizer(), + prompt_key="prompt", + chosen_key="chosen", + rejected_key="rejected", + pair_id_key="prompt_id", + prefetch_max_cached=0, + **kwargs, + ) + + +def test_explicit_pair_builds_identical_prompt_and_completion_only_masks(tmp_path: Path): + path = tmp_path / "pairs.jsonl" + _write_jsonl( + path, + [ + { + "prompt_id": "pair-1", + "prompt": [{"role": "user", "content": "question"}], + "chosen": {"role": "assistant", "content": "good"}, + "rejected": {"role": "assistant", "content": "bad"}, + } + ], + ) + + dataset = _dataset(path, max_length=32, max_completion_length=8, pair_capacity=64) + dataset.shuffle(0) + pairs, crossed = dataset.get_batch(1) + + assert crossed is False + assert len(pairs) == 1 + pair = pairs[0] + chosen_prompt = pair.chosen_tokens[: pair.chosen_prompt_length] + rejected_prompt = pair.rejected_tokens[: pair.rejected_prompt_length] + assert torch.equal(chosen_prompt, rejected_prompt) + assert pair.chosen_loss_mask[: pair.chosen_prompt_length].sum().item() == 0 + assert pair.rejected_loss_mask[: pair.rejected_prompt_length].sum().item() == 0 + assert pair.chosen_loss_mask[pair.chosen_prompt_length :].all() + assert pair.rejected_loss_mask[pair.rejected_prompt_length :].all() + + +def test_implicit_ultrafeedback_pair_extracts_strict_common_prefix(tmp_path: Path): + path = tmp_path / "pairs.jsonl" + _write_jsonl( + path, + [ + { + "prompt_id": "pair-1", + "chosen": [ + {"role": "user", "content": "question"}, + {"role": "assistant", "content": "good"}, + ], + "rejected": [ + {"role": "user", "content": "question"}, + {"role": "assistant", "content": "bad"}, + ], + } + ], + ) + + dataset = _dataset(path, max_length=32, max_completion_length=8, pair_capacity=64) + pair = dataset.get_processed_pair(0) + + assert pair.pair_id == "pair-1" + assert pair.chosen_completion_length == 4 + assert pair.rejected_completion_length == 3 + + +@pytest.mark.parametrize( + ("update", "match"), + [ + ({"prompt_id": None}, "prompt_id"), + ({"rejected": {"role": "user", "content": "bad"}}, "assistant"), + ({"rejected": {"role": "assistant", "content": "good"}}, "identical"), + ], +) +def test_pair_schema_rejects_invalid_rows(tmp_path: Path, update: dict, match: str): + row = { + "prompt_id": "pair-1", + "prompt": [{"role": "user", "content": "question"}], + "chosen": {"role": "assistant", "content": "good"}, + "rejected": {"role": "assistant", "content": "bad"}, + } + row.update(update) + path = tmp_path / "pairs.jsonl" + _write_jsonl(path, [row]) + + with pytest.raises(ValueError, match=match): + _dataset(path, max_length=32, max_completion_length=8, pair_capacity=64).get_processed_pair(0) + + +def test_preference_dataset_rejects_duplicate_pair_ids(tmp_path: Path): + row = { + "prompt_id": "duplicate", + "prompt": [{"role": "user", "content": "question"}], + "chosen": {"role": "assistant", "content": "good"}, + "rejected": {"role": "assistant", "content": "bad"}, + } + path = tmp_path / "pairs.jsonl" + _write_jsonl(path, [row, row]) + + with pytest.raises(ValueError, match="duplicate preference pair ID"): + _dataset(path, max_length=32, max_completion_length=8, pair_capacity=64) + + +def test_shared_prompt_and_completion_truncation_preserves_pair_difference(tmp_path: Path): + path = tmp_path / "pairs.jsonl" + _write_jsonl( + path, + [ + { + "prompt_id": "pair-1", + "prompt": [{"role": "user", "content": "0123456789"}], + "chosen": {"role": "assistant", "content": "chosen"}, + "rejected": {"role": "assistant", "content": "reject"}, + } + ], + ) + + pair = _dataset(path, max_length=8, max_completion_length=3, pair_capacity=16).get_processed_pair(0) + + assert pair.chosen_prompt_length == pair.rejected_prompt_length == 5 + assert pair.chosen_completion_length == pair.rejected_completion_length == 3 + assert pair.chosen_total_length + pair.rejected_total_length == 16 + assert not torch.equal( + pair.chosen_tokens[pair.chosen_prompt_length :], pair.rejected_tokens[pair.rejected_prompt_length :] + ) + + +def test_pack_pair_rows_and_custom_meta_are_aligned(tmp_path: Path): + path = tmp_path / "pairs.jsonl" + rows = [] + for idx in range(2): + rows.append( + { + "prompt_id": f"pair-{idx}", + "prompt": [{"role": "user", "content": f"q{idx}"}], + "chosen": {"role": "assistant", "content": f"yes{idx}"}, + "rejected": {"role": "assistant", "content": f"no{idx}"}, + } + ) + _write_jsonl(path, rows) + dataset = _dataset(path, max_length=16, max_completion_length=8, pair_capacity=32) + + batch, custom_meta = pack_preference_pairs_for_tq([dataset.get_processed_pair(0), dataset.get_processed_pair(1)]) + + assert len(batch["pair_ids"]) == len(custom_meta) == 2 + for idx, metadata in enumerate(custom_meta): + assert metadata["total_lengths"] == (batch["chosen_total_lengths"][idx] + batch["rejected_total_lengths"][idx]) diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py new file mode 100644 index 000000000..37f781a37 --- /dev/null +++ b/tests/engine/sft/test_preference_runtime.py @@ -0,0 +1,77 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Fail-fast validation for offline preference objectives.""" + +from argparse import Namespace + +import pytest + +from relax.engine.sft.runtime import is_preference_mode, validate_preference_args + + +def _args(**overrides) -> Namespace: + values = { + "loss_type": "sft", + "sft_objective": "dpo", + "custom_dataset_class_path": None, + "multimodal_keys": None, + "n_samples_per_prompt": 1, + "tensor_model_parallel_size": 1, + "pipeline_model_parallel_size": 1, + "context_parallel_size": 1, + "dynamic_context_parallel": False, + "qkv_format": "thd", + "fully_async": False, + "hybrid": False, + "sft_chunked_logits": False, + "enable_mtp_training": False, + "calculate_per_token_loss": False, + "lora_rank": 0, + "hidden_dropout": 0.0, + "attention_dropout": 0.0, + "sft_predict_interval": None, + "eval_interval": None, + "eval_prompt_data": None, + "eval_size": None, + "dpo_beta": 0.1, + "dpo_reference_free": False, + "ref_update_interval": None, + "enable_weights_backuper": True, + "preference_max_length": 1024, + "preference_max_completion_length": 512, + "seq_length": 2048, + } + values.update(overrides) + return Namespace(**values) + + +def test_preference_mode_is_nested_under_sft(): + assert is_preference_mode(_args()) + assert not is_preference_mode(_args(loss_type="policy_loss")) + assert not is_preference_mode(_args(sft_objective="causal_lm")) + assert not is_preference_mode(_args(sft_objective="reward_model")) + + +@pytest.mark.parametrize( + ("overrides", "match"), + [ + ({"n_samples_per_prompt": 2}, "n-samples-per-prompt"), + ({"tensor_model_parallel_size": 2}, "TP=CP=PP=1"), + ({"context_parallel_size": 2}, "TP=CP=PP=1"), + ({"dynamic_context_parallel": True}, "dynamic context"), + ({"qkv_format": "bshd"}, "qkv-format thd"), + ({"lora_rank": 8}, "LoRA"), + ({"hidden_dropout": 0.1}, "dropout"), + ({"ref_update_interval": 10}, "frozen reference"), + ({"dpo_beta": float("nan")}, "finite and positive"), + ({"preference_max_completion_length": 2048}, "must not exceed"), + ({"eval_prompt_data": ["heldout", "eval.jsonl"]}, "follow-up reward-modeling PR"), + ], +) +def test_preference_validation_rejects_unsupported_configs(overrides: dict, match: str): + with pytest.raises(ValueError, match=match): + validate_preference_args(_args(**overrides)) + + +def test_reference_free_dpo_does_not_require_ref_update_constraint(): + validate_preference_args(_args(dpo_reference_free=True, ref_update_interval=10)) diff --git a/tests/utils/training/test_preference_utils.py b/tests/utils/training/test_preference_utils.py new file mode 100644 index 000000000..4900c04b4 --- /dev/null +++ b/tests/utils/training/test_preference_utils.py @@ -0,0 +1,80 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Pure numerical and batching tests for offline preference training.""" + +import pytest +import torch +import torch.nn.functional as F + +from relax.utils.training.preference_utils import ( + build_causal_lm_labels, + dpo_pair_loss, + pack_preference_pair_indices, +) + + +def test_build_causal_lm_labels_uses_next_token_mask(): + tokens = torch.tensor([10, 11, 12, 13, 14]) + raw_mask = torch.tensor([0, 0, 1, 1, 1]) + + labels = build_causal_lm_labels(tokens, raw_mask) + + assert labels.tolist() == [-100, 12, 13, 14, -100] + + +@pytest.mark.parametrize("beta", [0.01, 0.1, 1.0]) +def test_dpo_pair_loss_matches_independent_reference_and_gradient(beta: float): + policy_chosen = torch.tensor([-2.0, -0.25, 4.0], dtype=torch.float32, requires_grad=True) + policy_rejected = torch.tensor([-3.0, 0.75, -1.0], dtype=torch.float32, requires_grad=True) + ref_chosen = torch.tensor([-2.5, 0.5, 1.0], dtype=torch.float32) + ref_rejected = torch.tensor([-2.0, -0.5, -2.0], dtype=torch.float32) + + actual = dpo_pair_loss( + policy_chosen, + policy_rejected, + reference_chosen=ref_chosen, + reference_rejected=ref_rejected, + beta=beta, + ) + expected = -F.logsigmoid(beta * ((policy_chosen - policy_rejected) - (ref_chosen - ref_rejected))) + assert torch.allclose(actual, expected, rtol=1e-6, atol=1e-6) + + actual.sum().backward() + actual_grad = policy_chosen.grad.detach().clone() + policy_chosen.grad = None + expected.sum().backward() + assert torch.allclose(actual_grad, policy_chosen.grad, rtol=1e-6, atol=1e-6) + + +def test_dpo_pair_loss_reference_free_matches_independent_reference(): + chosen = torch.tensor([-1.0, 2.0], requires_grad=True) + rejected = torch.tensor([0.5, -2.0], requires_grad=True) + + actual = dpo_pair_loss(chosen, rejected, beta=0.1, reference_free=True) + expected = -F.logsigmoid(0.1 * (chosen - rejected)) + + assert torch.allclose(actual, expected, rtol=1e-6, atol=1e-6) + + +def test_dpo_pair_loss_rejects_missing_reference_and_non_finite_values(): + finite = torch.tensor([0.0]) + with pytest.raises(ValueError, match="reference log-probabilities"): + dpo_pair_loss(finite, finite) + with pytest.raises(ValueError, match="finite"): + dpo_pair_loss(torch.tensor([float("nan")]), finite, reference_free=True) + + +def test_pair_packer_is_deterministic_complete_and_capacity_safe(): + costs = [2, 4, 4, 5, 5] + pair_ids = ["a", "b", "c", "d", "e"] + + bins = pack_preference_pair_indices(costs, pair_ids, capacity=10) + + assert sorted(index for group in bins for index in group) == list(range(len(costs))) + assert all(sum(costs[index] for index in group) <= 10 for group in bins) + assert bins == pack_preference_pair_indices(costs, pair_ids, capacity=10) + + +def test_pair_packer_reports_oversize_pair(): + with pytest.raises(ValueError, match="oversize.*pair-a.*11"): + pack_preference_pair_indices([11], ["pair-a"], capacity=10) From 46154cde4a03d4cdafb4400464fa56c2d8a8413d Mon Sep 17 00:00:00 2001 From: A-Words Date: Fri, 7 Aug 2026 21:52:53 +0800 Subject: [PATCH 02/25] fix(sft): enforce DPO reference integrity --- relax/backends/megatron/actor.py | 247 +++++++++++++++++- relax/backends/megatron/checkpoint.py | 6 +- relax/backends/megatron/data.py | 34 ++- relax/backends/megatron/loss.py | 40 ++- relax/backends/megatron/model.py | 2 + .../backends/megatron/reference_integrity.py | 175 +++++++++++++ relax/engine/sft/dataset/preference.py | 86 +++++- relax/engine/sft/runtime.py | 3 + relax/utils/arguments.py | 2 + relax/utils/training/preference_utils.py | 38 +++ .../data/prepare_ultrafeedback_preferences.py | 34 ++- .../dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 6 +- tests/backends/megatron/test_dpo_loss.py | 139 ++++++++++ .../megatron/test_dpo_reference_integrity.py | 177 +++++++++++++ .../megatron/test_preference_batching.py | 94 +++++++ tests/engine/sft/dataset/test_preference.py | 27 +- tests/engine/sft/test_preference_runtime.py | 7 + 17 files changed, 1083 insertions(+), 34 deletions(-) create mode 100644 relax/backends/megatron/reference_integrity.py create mode 100644 tests/backends/megatron/test_dpo_loss.py create mode 100644 tests/backends/megatron/test_dpo_reference_integrity.py create mode 100644 tests/backends/megatron/test_preference_batching.py diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index 7b26f7401..26a0949cd 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -7,6 +7,7 @@ import time from argparse import Namespace from contextlib import nullcontext +from dataclasses import replace from functools import partial from typing import Any, List @@ -78,7 +79,7 @@ from ...utils.profile_utils import TrainProfiler from ...utils.training.tensor_backper import TensorBackuper -from .checkpoint import load_checkpoint +from .checkpoint import is_megatron_checkpoint, load_checkpoint from .cp_utils import all_gather_with_cp, maybe_padded_total_lengths, slice_with_cp from .data import ( ROLLOUT_MINI_LOCAL_SAMPLE_COUNTS_KEY, @@ -94,6 +95,16 @@ from .initialize import init, is_megatron_main_rank from .loss import compute_advantages_and_returns, get_log_probs_and_entropy, get_values from .model import forward_only, initialize_model_and_optimizer, save, train +from .reference_integrity import ( + REFERENCE_LOADER_MODE, + DPOReferenceIdentity, + canonical_optimizer_sha256, + canonical_tensor_sha256, + read_reference_identity, + reference_identity_path, + reference_probe_sha256, + write_reference_identity, +) from .weight_update.common import named_params_and_buffers from .weight_update.update_weight_from_distributed import UpdateWeightFromDistributed from .weight_update.update_weight_from_tensor import UpdateWeightFromTensor @@ -238,9 +249,13 @@ def _init( self.args.lr = self.args.critic_lr self.args.lr_warmup_iters = self.args.critic_lr_warmup_iters + resumed_from_megatron = is_megatron_checkpoint(args.load) self.model, self.optimizer, self.opt_param_scheduler, loaded_rollout_id = initialize_model_and_optimizer( args, role ) + self._dpo_reference_identity: DPOReferenceIdentity | None = None + self._expected_dpo_reference_identity: DPOReferenceIdentity | None = None + self._dpo_reference_probe_verified = False start_rollout_id = loaded_rollout_id + 1 @@ -270,12 +285,13 @@ def _init( if with_ref: if is_preference_mode(args) and args.sft_objective == "dpo": - if loaded_rollout_id < 0: + if not resumed_from_megatron: self.weights_backuper.backup("ref") + self._dpo_reference_identity = self._build_dpo_reference_identity() else: - self.load_other_checkpoint("ref", args.hf_checkpoint) - self._active_model_tag = "ref" - self._switch_model("actor") + identity_path = reference_identity_path(args.load, loaded_rollout_id) + self._expected_dpo_reference_identity = read_reference_identity(identity_path) + self._rebuild_dpo_reference(args.hf_checkpoint) else: self.load_other_checkpoint("ref", args.ref_load) @@ -436,6 +452,190 @@ def _switch_model(self, target_tag: str) -> None: self.weights_backuper.restore(target_tag) self._active_model_tag = target_tag + def _is_standard_dpo(self) -> bool: + return is_preference_mode(self.args) and self.args.sft_objective == "dpo" and not self.args.dpo_reference_free + + def _build_dpo_reference_identity(self, *, probe_sha256: str | None = None) -> DPOReferenceIdentity: + parameter_sha256 = canonical_tensor_sha256(self.weights_backuper.get("ref").items()) + self._assert_dp_reference_digest_equal(parameter_sha256) + return DPOReferenceIdentity( + schema_version=1, + repository=self.args.dpo_reference_repository, + revision=self.args.dpo_reference_revision, + loader_mode=REFERENCE_LOADER_MODE, + parameter_sha256=parameter_sha256, + probe_sha256=probe_sha256, + probe_manifest=None, + ) + + def _assert_dp_reference_digest_equal(self, digest: str) -> None: + digests = [None] * dist.get_world_size(group=get_gloo_group()) + dist.all_gather_object(digests, digest, group=get_gloo_group()) + if len(set(digests)) != 1: + raise RuntimeError(f"DPO frozen-reference parameter digests differ across ranks: {digests}") + + def _assert_dpo_reference_identity(self, actual: DPOReferenceIdentity) -> None: + expected = self._expected_dpo_reference_identity + if expected is None: + return + fields = ("repository", "revision", "loader_mode", "parameter_sha256") + mismatches = { + field: (getattr(expected, field), getattr(actual, field)) + for field in fields + if getattr(expected, field) != getattr(actual, field) + } + if mismatches: + raise RuntimeError(f"DPO frozen-reference identity mismatch: {mismatches}") + + def _rebuild_dpo_reference(self, path: str) -> None: + """Transactionally rebuild a frozen reference without touching + optimizer state.""" + if self._active_model_tag != "actor" or "actor" not in self.weights_backuper.backup_tags: + raise RuntimeError("DPO reference rebuild requires an active actor backup") + optimizer_before = canonical_optimizer_sha256(self.optimizer) + old_args = self.args.load, self.args.no_load_optim, self.args.no_load_rng, self.args.finetune + try: + self.args.load = path + self.args.no_load_optim = True + self.args.no_load_rng = True + self.args.finetune = True + self._active_model_tag = None + load_checkpoint( + self.model, + None, + None, + checkpointing_context={}, + skip_load_to_model_and_opt=False, + ) + candidate_sha256 = canonical_tensor_sha256( + named_params_and_buffers( + self.args, + self.model, + convert_to_global_name=self.args.megatron_to_hf_mode == "raw", + translate_gpu_to_cpu=True, + ) + ) + self._assert_dp_reference_digest_equal(candidate_sha256) + candidate = DPOReferenceIdentity( + schema_version=1, + repository=self.args.dpo_reference_repository, + revision=self.args.dpo_reference_revision, + loader_mode=REFERENCE_LOADER_MODE, + parameter_sha256=candidate_sha256, + probe_sha256=None, + probe_manifest=None, + ) + self._assert_dpo_reference_identity(candidate) + self.weights_backuper.backup("ref") + self._dpo_reference_identity = candidate + finally: + self.args.load, self.args.no_load_optim, self.args.no_load_rng, self.args.finetune = old_args + self._switch_model("actor") + optimizer_after = canonical_optimizer_sha256(self.optimizer) + if optimizer_after != optimizer_before: + raise RuntimeError( + "DPO reference rebuild modified optimizer master parameters or state: " + f"before={optimizer_before}, after={optimizer_after}" + ) + + def _validate_dpo_reference_probe(self, rollout_data: RolloutBatch) -> None: + if self._expected_dpo_reference_identity is not None: + if not self._dpo_reference_probe_verified: + raise RuntimeError("resumed DPO reference probe must be replayed before training data forward") + return + if self._dpo_reference_identity is not None and self._dpo_reference_identity.probe_sha256 is not None: + return + first_pair_id = int(rollout_data["preference_branch_pair_ids"][0]) + indices = [ + index + for index, pair_id in enumerate(rollout_data["preference_branch_pair_ids"]) + if int(pair_id) == first_pair_id + ] + if len(indices) != 2: + raise RuntimeError(f"DPO reference probe pair {first_pair_id!r} is not atomic") + manifest = { + "pair_ids": [int(rollout_data["preference_branch_pair_ids"][index]) for index in indices], + "branch_is_chosen": [bool(rollout_data["preference_is_chosen"][index]) for index in indices], + "tokens": [torch.as_tensor(rollout_data["tokens"][index]).cpu().tolist() for index in indices], + "loss_masks": [torch.as_tensor(rollout_data["loss_masks"][index]).cpu().tolist() for index in indices], + "total_lengths": [int(rollout_data["total_lengths"][index]) for index in indices], + "response_lengths": [int(rollout_data["response_lengths"][index]) for index in indices], + } + if self._dpo_reference_identity is None: + raise RuntimeError("DPO frozen-reference identity was not initialized") + probe_sha256 = self._compute_dpo_reference_probe(manifest) + self._dpo_reference_identity = replace( + self._dpo_reference_identity, probe_sha256=probe_sha256, probe_manifest=manifest + ) + + def _compute_dpo_reference_probe(self, manifest: dict[str, Any]) -> str: + """Run the canonical single-pair probe without perturbing training + RNG.""" + pair_ids = [int(value) for value in manifest["pair_ids"]] + branch_is_chosen = [bool(value) for value in manifest["branch_is_chosen"]] + if len(pair_ids) != 2 or set(branch_is_chosen) != {False, True} or len(set(pair_ids)) != 1: + raise RuntimeError("DPO reference probe manifest must contain one atomic preference pair") + device = device_utils.make_current_torch_device() + tokens = [torch.tensor(value, dtype=torch.long, device=device) for value in manifest["tokens"]] + loss_masks = [torch.tensor(value, dtype=torch.bool, device=device) for value in manifest["loss_masks"]] + total_lengths = [int(value) for value in manifest["total_lengths"]] + response_lengths = [int(value) for value in manifest["response_lengths"]] + dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) + probe_data: RolloutBatch = { + "tokens": tokens, + "loss_masks": loss_masks, + "total_lengths": total_lengths, + "response_lengths": response_lengths, + "preference_branch_pair_ids": pair_ids, + "preference_is_chosen": branch_is_chosen, + "preference_pair_ids": [pair_ids[0]], + "preference_pair_costs": [sum(total_lengths)], + "dynamic_global_batch_size": dp_size, + } + probe_iterator, probe_microbatches = get_data_iterator(self.args, self.model, probe_data) + restore_tag = self._active_model_tag + if restore_tag is None: + raise RuntimeError("DPO reference probe requires an active model backup") + python_rng_state = random.getstate() + torch_rng_state = torch.get_rng_state() + cuda_rng_states = torch.cuda.get_rng_state_all() + try: + self._switch_model("ref") + output = self.compute_log_prob(probe_iterator, probe_microbatches, store_prefix="ref_") + finally: + self._switch_model(restore_tag) + random.setstate(python_rng_state) + torch.set_rng_state(torch_rng_state) + torch.cuda.set_rng_state_all(cuda_rng_states) + return reference_probe_sha256( + pair_ids, + branch_is_chosen, + tokens, + loss_masks, + output["ref_log_probs"], + ) + + def _replay_dpo_reference_probe(self) -> None: + expected = self._expected_dpo_reference_identity + if expected is None or self._dpo_reference_probe_verified: + return + manifest = expected.probe_manifest + if expected.probe_sha256 is None or manifest is None: + raise RuntimeError("resumed DPO checkpoint is missing frozen-reference probe metadata") + actual = self._compute_dpo_reference_probe(manifest) + if actual != expected.probe_sha256: + raise RuntimeError( + f"DPO frozen-reference probe mismatch: expected={expected.probe_sha256}, actual={actual}" + ) + if self._dpo_reference_identity is None: + raise RuntimeError("DPO frozen-reference identity was not initialized") + self._dpo_reference_identity = replace( + self._dpo_reference_identity, + probe_sha256=expected.probe_sha256, + probe_manifest=manifest, + ) + self._dpo_reference_probe_verified = True + def fill_routing_replay(self, data_iterator, num_microbatches, rollout_data): if "rollout_routed_experts" not in rollout_data: raise ValueError( @@ -805,6 +1005,8 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: # Create data iterator for actor forward + routing replay + train. data_iterator, num_microbatches = get_data_iterator(self.args, self.model, rollout_data) + if self._is_standard_dpo(): + self._replay_dpo_reference_probe() # Create a separate iterator with a larger token budget for ref/teacher log-probs if self.args.use_dynamic_batch_size and self.args.log_probs_max_tokens_per_gpu != self.args.max_tokens_per_gpu: data_iterator_logprobs, num_microbatches_logprobs = get_data_iterator( @@ -836,14 +1038,19 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: if "ref" in self.weights_backuper.backup_tags: if self.args.use_routing_replay: os.environ["ROUTING_REPLAY_STAGE"] = "fallthrough" - self._switch_model("ref") - rollout_data.update( - self.compute_log_prob( - data_iterator_logprobs, - num_microbatches_logprobs, - store_prefix="ref_", + try: + self._switch_model("ref") + rollout_data.update( + self.compute_log_prob( + data_iterator_logprobs, + num_microbatches_logprobs, + store_prefix="ref_", + ) ) - ) + finally: + self._switch_model("old_actor" if self.args.keep_old_actor else "actor") + if standard_dpo: + self._validate_dpo_reference_probe(rollout_data) # Forward teacher model to get teacher_log_probs for Megatron-based OPD if "teacher" in self.weights_backuper.backup_tags: @@ -1605,9 +1812,23 @@ def save_model(self, rollout_id: int, force_sync: bool = False) -> None: save(rollout_id, self.model, self.optimizer, self.opt_param_scheduler) - if force_sync and self.args.async_save: + if (force_sync or self._is_standard_dpo()) and self.args.async_save: maybe_finalize_async_save(blocking=True) + if self._is_standard_dpo(): + identity = self._dpo_reference_identity + if identity is None or identity.probe_sha256 is None: + raise RuntimeError("cannot save standard DPO without a validated reference identity and probe") + actual_sha256 = canonical_tensor_sha256(self.weights_backuper.get("ref").items()) + if actual_sha256 != identity.parameter_sha256: + raise RuntimeError( + "DPO frozen-reference checksum changed before checkpoint: " + f"expected={identity.parameter_sha256}, actual={actual_sha256}" + ) + if dist.get_rank() == 0: + write_reference_identity(reference_identity_path(self.args.save, rollout_id), identity) + dist.barrier(group=get_gloo_group()) + if self.args.save_hf is not None and self.role == "actor": from relax.backends.megatron.model import save_hf_model diff --git a/relax/backends/megatron/checkpoint.py b/relax/backends/megatron/checkpoint.py index 4fd8b7d6f..08e8b31b4 100644 --- a/relax/backends/megatron/checkpoint.py +++ b/relax/backends/megatron/checkpoint.py @@ -109,7 +109,7 @@ def load_checkpoint(ddp_model, optimizer, opt_param_scheduler, checkpointing_con exist = Path(load_path).exists() and _is_dir_nonempty(load_path) - if exist and _is_megatron_checkpoint(load_path): + if exist and is_megatron_checkpoint(load_path): try: return _load_checkpoint_megatron( ddp_model=ddp_model, @@ -168,7 +168,9 @@ def _format_opt_param_scheduler_error(args, original: AssertionError) -> str: ) -def _is_megatron_checkpoint(path: str | Path) -> bool: +def is_megatron_checkpoint(path: str | Path | None) -> bool: + if path is None: + return False return (Path(path) / "latest_checkpointed_iteration.txt").is_file() or bool( re.fullmatch(r"iter_\d{7}", Path(path).name) ) diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index d254ca1b8..c7aec5fd1 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -763,6 +763,8 @@ def expand_preference_rollout_data(rollout_data: RolloutBatch) -> RolloutBatch: flat["preference_is_chosen"].append(is_chosen) flat["preference_pair_costs"] = pair_costs flat["preference_pair_ids"] = pair_ids + if "dynamic_global_batch_size" in rollout_data: + flat["dynamic_global_batch_size"] = rollout_data["dynamic_global_batch_size"] return flat @@ -789,19 +791,39 @@ def _get_preference_data_iterator( pair_costs = [int(cost) for cost in rollout_data["preference_pair_costs"]] pair_ids = [str(pair_id) for pair_id in rollout_data["preference_pair_ids"]] dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) - if int(args.global_batch_size) % dp_size != 0: - raise ValueError("pair-valued global batch size must be divisible by data parallel size") - expected_local_pairs = int(args.global_batch_size) // dp_size - if len(pair_costs) != expected_local_pairs: + count_tensor = torch.tensor([len(pair_costs)], dtype=torch.int64, device=device_utils.make_current_torch_device()) + count_min = count_tensor.clone() + count_max = count_tensor.clone() + dist.all_reduce(count_tensor, op=dist.ReduceOp.SUM, group=mpu.get_data_parallel_group()) + dist.all_reduce(count_min, op=dist.ReduceOp.MIN, group=mpu.get_data_parallel_group()) + dist.all_reduce(count_max, op=dist.ReduceOp.MAX, group=mpu.get_data_parallel_group()) + step_global_pair_count = int(count_tensor.item()) + if int(count_min.item()) != int(count_max.item()): raise ValueError( - "preference local pair count does not match pair-valued global batch size: " - f"local={len(pair_costs)}, expected={expected_local_pairs}, dp_size={dp_size}" + "preference objectives require equal local pair rows on every DP rank: " + f"global_min={int(count_min.item())}, global_max={int(count_max.item())}" ) + dynamic_count = rollout_data.get("dynamic_global_batch_size") + if isinstance(dynamic_count, (list, tuple)): + normalized = {int(value) for value in dynamic_count} + if len(normalized) != 1: + raise ValueError(f"dynamic_global_batch_size values must be identical, got {dynamic_count}") + dynamic_count = normalized.pop() + expected_global_pairs = int(args.global_batch_size) if dynamic_count is None else int(dynamic_count) + if expected_global_pairs != step_global_pair_count: + raise ValueError( + "dynamic_global_batch_size must equal the step-global preference pair count: " + f"declared={expected_global_pairs}, actual={step_global_pair_count}, " + f"local={len(pair_costs)}, dp_size={dp_size}" + ) + rollout_data["dynamic_global_batch_size"] = step_global_pair_count capacity = int(max_tokens_per_gpu or args.max_tokens_per_gpu) pair_bins = pack_preference_pair_indices(pair_costs, pair_ids, capacity=capacity) bin_count = torch.tensor([len(pair_bins)], dtype=torch.int, device=device_utils.make_current_torch_device()) dist.all_reduce(bin_count, op=dist.ReduceOp.MAX, group=mpu.get_data_parallel_group()) pair_bins = _split_preference_bins_to_count(pair_bins, int(bin_count.item())) + if any(sum(pair_costs[index] for index in group) > capacity for group in pair_bins): + raise RuntimeError("preference DP bin synchronization produced an over-capacity micro-batch") branch_bins = [ [branch for pair_index in group for branch in (2 * pair_index, 2 * pair_index + 1)] for group in pair_bins ] diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 0075619de..8ff05f826 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -32,7 +32,7 @@ get_reinforce_plus_plus_baseline_advantages, get_reinforce_plus_plus_returns, ) -from relax.utils.training.preference_utils import dpo_pair_loss +from relax.utils.training.preference_utils import build_preference_pair_indices, dpo_pair_loss from relax.utils.types import RolloutBatch from .cp_utils import ( @@ -1185,8 +1185,7 @@ def dpo_loss_function( logits: torch.Tensor, sum_of_sample_mean: Callable[[torch.Tensor], torch.Tensor], # noqa: ARG001 ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: - """Compute a pair-summed DPO objective over adjacent chosen/rejected - branches.""" + """Compute a pair-summed DPO objective using explicit pair identity.""" if len(batch["response_lengths"]) % 2 != 0: raise ValueError("DPO micro-batch must contain an even number of chosen/rejected branches") _, values = get_log_probs_and_entropy( @@ -1215,11 +1214,22 @@ def sequence_sums(token_values) -> torch.Tensor: "DPO branch log-probability/mask shape mismatch: " f"{tuple(branch_values.shape)} vs {tuple(branch_mask.shape)}" ) + if not bool(branch_mask.to(dtype=torch.bool).any()): + raise ValueError("DPO branch completion mask must contain at least one supervised token") sums.append((branch_values * branch_mask).sum()) return torch.stack(sums) + pair_ids = batch.get("preference_branch_pair_ids") + branch_is_chosen = batch.get("preference_is_chosen") + if pair_ids is None or branch_is_chosen is None: + raise ValueError("DPO batch is missing preference pair identity fields") + chosen_indices, rejected_indices = build_preference_pair_indices(pair_ids, branch_is_chosen) + chosen_index = torch.as_tensor(chosen_indices, dtype=torch.long, device=logits.device) + rejected_index = torch.as_tensor(rejected_indices, dtype=torch.long, device=logits.device) + policy_sums = sequence_sums(policy_token_log_probs) - policy_chosen, policy_rejected = policy_sums[0::2], policy_sums[1::2] + policy_chosen = policy_sums.index_select(0, chosen_index) + policy_rejected = policy_sums.index_select(0, rejected_index) reference_free = bool(args.dpo_reference_free) if reference_free: reference_chosen = reference_rejected = None @@ -1230,7 +1240,8 @@ def sequence_sums(token_values) -> torch.Tensor: if reference_values is None: raise ValueError("standard DPO batch is missing frozen-reference log-probabilities") reference_sums = sequence_sums(reference_values) - reference_chosen, reference_rejected = reference_sums[0::2], reference_sums[1::2] + reference_chosen = reference_sums.index_select(0, chosen_index) + reference_rejected = reference_sums.index_select(0, rejected_index) ref_chosen_for_metrics = reference_chosen ref_rejected_for_metrics = reference_rejected pair_losses = dpo_pair_loss( @@ -1246,13 +1257,26 @@ def sequence_sums(token_values) -> torch.Tensor: loss = pair_losses.sum() if pair_losses.numel() == 0: loss = loss + 0 * logits.sum() - return loss, { + reward_margin = chosen_rewards - rejected_rewards + tie = reward_margin.abs() <= 1e-6 + strict = reward_margin > 0 + correct = reward_margin > 1e-6 + metrics = { "loss": pair_losses.detach().sum(), + "dpo_logps_chosen": policy_chosen.detach().sum(), + "dpo_logps_rejected": policy_rejected.detach().sum(), "dpo_chosen_reward": chosen_rewards.detach().sum(), "dpo_rejected_reward": rejected_rewards.detach().sum(), - "dpo_reward_margin": (chosen_rewards - rejected_rewards).detach().sum(), - "dpo_pair_accuracy": (chosen_rewards > rejected_rewards).to(torch.float32).detach().sum(), + "dpo_reward_margin": reward_margin.detach().sum(), + "dpo_strict_accuracy": strict.to(torch.float32).detach().sum(), + "dpo_tie_rate": tie.to(torch.float32).detach().sum(), + "dpo_tie_aware_accuracy": (correct.to(torch.float32) + 0.5 * tie.to(torch.float32)).detach().sum(), } + metrics["dpo_pair_accuracy"] = metrics["dpo_strict_accuracy"] + if not reference_free: + metrics["dpo_ref_logps_chosen"] = reference_chosen.detach().sum() + metrics["dpo_ref_logps_rejected"] = reference_rejected.detach().sum() + return loss, metrics def sft_loss_function_chunked( diff --git a/relax/backends/megatron/model.py b/relax/backends/megatron/model.py index 2e09505ef..b80bd307b 100644 --- a/relax/backends/megatron/model.py +++ b/relax/backends/megatron/model.py @@ -979,6 +979,8 @@ def forward_step( "loss_masks", "log_probs", "ref_log_probs", + "preference_branch_pair_ids", + "preference_is_chosen", "values", "advantages", "returns", diff --git a/relax/backends/megatron/reference_integrity.py b/relax/backends/megatron/reference_integrity.py new file mode 100644 index 000000000..93e77c760 --- /dev/null +++ b/relax/backends/megatron/reference_integrity.py @@ -0,0 +1,175 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""DPO frozen-reference identity and byte-level integrity helpers.""" + +import hashlib +import json +import os +from collections.abc import Iterable, Mapping, Sequence +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any + +import torch + + +REFERENCE_IDENTITY_FILENAME = "relax_dpo_reference.json" +REFERENCE_LOADER_MODE = "hf_bridge_model_only_v1" + + +@dataclass(frozen=True) +class DPOReferenceIdentity: + """Identity persisted beside every standard-DPO checkpoint.""" + + schema_version: int + repository: str + revision: str + loader_mode: str + parameter_sha256: str + probe_sha256: str | None + probe_manifest: dict[str, Any] | None = None + + @classmethod + def from_dict(cls, value: Mapping[str, Any]) -> "DPOReferenceIdentity": + return cls( + schema_version=int(value["schema_version"]), + repository=str(value["repository"]), + revision=str(value["revision"]), + loader_mode=str(value["loader_mode"]), + parameter_sha256=str(value["parameter_sha256"]), + probe_sha256=None if value.get("probe_sha256") is None else str(value["probe_sha256"]), + probe_manifest=None if value.get("probe_manifest") is None else dict(value["probe_manifest"]), + ) + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +def _update_field(digest: Any, value: bytes) -> None: + digest.update(len(value).to_bytes(8, "big")) + digest.update(value) + + +def _tensor_bytes(tensor: torch.Tensor) -> bytes: + value = tensor.detach().cpu().contiguous().reshape(-1) + return value.view(torch.uint8).numpy().tobytes() + + +def canonical_tensor_sha256(named_tensors: Iterable[tuple[str, torch.Tensor]]) -> str: + """Hash names, dtype, shape and bytes in canonical name order.""" + normalized = sorted(((str(name), tensor) for name, tensor in named_tensors), key=lambda item: item[0]) + if not normalized: + raise ValueError("canonical tensor digest requires at least one tensor") + digest = hashlib.sha256() + for name, tensor in normalized: + _update_field(digest, name.encode()) + _update_field(digest, str(tensor.dtype).encode()) + _update_field(digest, json.dumps(list(tensor.shape), separators=(",", ":")).encode()) + _update_field(digest, _tensor_bytes(tensor)) + return digest.hexdigest() + + +def canonical_optimizer_sha256(optimizer: Any) -> str: + """Hash optimizer master parameters and state without relying on object + IDs.""" + digest = hashlib.sha256() + + def update(value: Any, path: str) -> None: + _update_field(digest, path.encode()) + if isinstance(value, torch.Tensor): + _update_field(digest, str(value.dtype).encode()) + _update_field(digest, json.dumps(list(value.shape), separators=(",", ":")).encode()) + _update_field(digest, _tensor_bytes(value)) + elif isinstance(value, Mapping): + for key in sorted(value, key=lambda item: str(item)): + update(value[key], f"{path}/{key}") + elif isinstance(value, (list, tuple)): + for index, item in enumerate(value): + update(item, f"{path}/{index}") + else: + _update_field(digest, repr(value).encode()) + + chained = getattr(optimizer, "chained_optimizers", None) + if chained is not None: + optimizers = [getattr(item, "optimizer", item) for item in chained] + else: + optimizers = [getattr(optimizer, "optimizer", optimizer)] + for optimizer_index, inner_optimizer in enumerate(optimizers): + param_groups = getattr(inner_optimizer, "param_groups", None) + state = getattr(inner_optimizer, "state", None) + if param_groups is None or state is None: + update(inner_optimizer.state_dict(), f"optimizer/{optimizer_index}/state_dict") + continue + for group_index, group in enumerate(param_groups): + update( + {key: value for key, value in group.items() if key != "params"}, + f"optimizer/{optimizer_index}/group/{group_index}/options", + ) + for parameter_index, parameter in enumerate(group["params"]): + path = f"optimizer/{optimizer_index}/group/{group_index}/parameter/{parameter_index}" + update(parameter, f"{path}/master") + update(state.get(parameter, {}), f"{path}/state") + return digest.hexdigest() + + +def reference_probe_sha256( + pair_ids: Sequence[int], + branch_is_chosen: Sequence[bool], + tokens: Sequence[Sequence[int] | torch.Tensor], + loss_masks: Sequence[Sequence[int] | torch.Tensor], + ref_log_probs: Sequence[Sequence[float] | torch.Tensor], +) -> str: + """Hash the exact completion-only frozen-reference probe output.""" + size = len(pair_ids) + if any(len(values) != size for values in (branch_is_chosen, tokens, loss_masks, ref_log_probs)): + raise ValueError("reference probe fields must be branch aligned") + digest = hashlib.sha256() + for index in range(size): + _update_field(digest, str(int(pair_ids[index])).encode()) + _update_field(digest, b"chosen" if bool(branch_is_chosen[index]) else b"rejected") + token_tensor = torch.as_tensor(tokens[index], dtype=torch.int64) + mask_tensor = torch.as_tensor(loss_masks[index], dtype=torch.bool) + logp_tensor = torch.as_tensor(ref_log_probs[index], dtype=torch.float32) + if logp_tensor.shape != mask_tensor.shape: + raise ValueError("reference probe log-probability/mask shape mismatch") + _update_field(digest, _tensor_bytes(token_tensor)) + _update_field(digest, _tensor_bytes(mask_tensor)) + masked_log_probs = logp_tensor * mask_tensor.to(device=logp_tensor.device, dtype=torch.float32) + _update_field(digest, _tensor_bytes(masked_log_probs)) + return digest.hexdigest() + + +def reference_identity_path(checkpoint_root: str | os.PathLike[str], iteration: int) -> Path: + root = Path(checkpoint_root) + iteration_dir = root if root.name == f"iter_{iteration:07d}" else root / f"iter_{iteration:07d}" + return iteration_dir / REFERENCE_IDENTITY_FILENAME + + +def write_reference_identity(path: Path, identity: DPOReferenceIdentity) -> None: + """Atomically write a reference identity sidecar.""" + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(f"{path.suffix}.tmp.{os.getpid()}") + temporary.write_text(json.dumps(identity.to_dict(), indent=2, sort_keys=True) + "\n", encoding="utf-8") + os.replace(temporary, path) + + +def read_reference_identity(path: Path) -> DPOReferenceIdentity: + if not path.is_file(): + raise FileNotFoundError(f"DPO reference identity sidecar is missing: {path}") + identity = DPOReferenceIdentity.from_dict(json.loads(path.read_text(encoding="utf-8"))) + if identity.schema_version != 1: + raise ValueError(f"unsupported DPO reference identity schema: {identity.schema_version}") + return identity + + +__all__ = [ + "DPOReferenceIdentity", + "REFERENCE_IDENTITY_FILENAME", + "REFERENCE_LOADER_MODE", + "canonical_optimizer_sha256", + "canonical_tensor_sha256", + "read_reference_identity", + "reference_identity_path", + "reference_probe_sha256", + "write_reference_identity", +] diff --git a/relax/engine/sft/dataset/preference.py b/relax/engine/sft/dataset/preference.py index 995e0450b..6104c2582 100644 --- a/relax/engine/sft/dataset/preference.py +++ b/relax/engine/sft/dataset/preference.py @@ -4,6 +4,7 @@ import hashlib import threading +from collections import Counter from dataclasses import dataclass from typing import Any @@ -23,6 +24,31 @@ logger = get_logger(__name__) +class PreferenceDataError(ValueError): + """Stable, classified preference-row rejection.""" + + def __init__(self, reason_code: str, message: str, *, source_idx: int, pair_id: str | None = None) -> None: + super().__init__(message) + self.reason_code = reason_code + self.source_idx = source_idx + self.pair_id = pair_id + + +def _classify_preference_error(error: BaseException) -> str: + message = str(error).lower() + if "post-truncation identical" in message: + return "post_truncation" + if "must not be identical" in message: + return "identical" + if "prompt tokens differ" in message or "strict common prefix" in message: + return "prompt_mismatch" + if "empty completion" in message or "no supervised tokens" in message: + return "empty_completion" + if "capacity" in message or "exceeds max_length" in message: + return "oversize" + return "schema" + + @dataclass(frozen=True) class PreferencePair: """Canonical text-only preference pair before tokenization.""" @@ -212,6 +238,9 @@ def __init__( self.apply_chat_template_kwargs = apply_chat_template_kwargs self.expected_chat_template_sha256 = expected_chat_template_sha256 self.require_no_generation_marker = require_no_generation_marker + self._rejection_counts: Counter[str] = Counter() + self._rejection_records: list[dict[str, Any]] = [] + self._rejection_lock = threading.Lock() self._template_contract_validated = False self._template_contract_lock = threading.Lock() self._validate_unique_pair_ids() @@ -234,9 +263,21 @@ def _validate_unique_pair_ids(self) -> None: for index in range(len(self.reader)): pair_id = self.reader[index].get(self.pair_id_key) if not isinstance(pair_id, str) or not pair_id: - raise ValueError(f"preference row {index} requires a non-empty {self.pair_id_key}") + message = f"preference row {index} requires a non-empty {self.pair_id_key}" + with self._rejection_lock: + self._rejection_counts["schema"] += 1 + self._rejection_records.append( + {"source_idx": index, "pair_id": None, "reason_code": "schema", "message": message} + ) + raise PreferenceDataError("schema", message, source_idx=index) if pair_id in seen: - raise ValueError(f"duplicate preference pair ID {pair_id!r} at row {index}") + message = f"duplicate preference pair ID {pair_id!r} at row {index}" + with self._rejection_lock: + self._rejection_counts["schema"] += 1 + self._rejection_records.append( + {"source_idx": index, "pair_id": pair_id, "reason_code": "schema", "message": message} + ) + raise PreferenceDataError("schema", message, source_idx=index, pair_id=pair_id) seen.add(pair_id) def shuffle(self, epoch_id: int, position: int = 0) -> None: @@ -264,6 +305,34 @@ def get_canonical_pair(self, idx: int) -> PreferencePair: ) def get_processed_pair(self, idx: int) -> ProcessedPreferencePair: + try: + return self._get_processed_pair(idx) + except PreferenceDataError: + raise + except Exception as exc: + pair_id = None + try: + raw_pair_id = self.reader[idx].get(self.pair_id_key) + pair_id = raw_pair_id if isinstance(raw_pair_id, str) else None + except Exception: + pass + reason_code = _classify_preference_error(exc) + error = PreferenceDataError(reason_code, str(exc), source_idx=idx, pair_id=pair_id) + with self._rejection_lock: + self._rejection_counts[reason_code] += 1 + self._rejection_records.append( + {"source_idx": idx, "pair_id": pair_id, "reason_code": reason_code, "message": str(exc)} + ) + logger.error( + "Rejected preference pair source_idx=%s pair_id=%r reason_code=%s counts=%s", + idx, + pair_id, + reason_code, + dict(self.rejection_counts), + ) + raise error from exc + + def _get_processed_pair(self, idx: int) -> ProcessedPreferencePair: if self.tokenizer is None: raise RuntimeError("PreferenceStreamingDataset requires a tokenizer for processing") pair = self.get_canonical_pair(idx) @@ -320,6 +389,18 @@ def get_processed_pair(self, idx: int) -> ProcessedPreferencePair: source_idx=idx, ) + @property + def rejection_counts(self) -> dict[str, int]: + """Return a thread-safe snapshot of classified rejection counts.""" + with self._rejection_lock: + return dict(self._rejection_counts) + + @property + def rejection_records(self) -> list[dict[str, Any]]: + """Return row IDs and stable reason codes for evidence manifests.""" + with self._rejection_lock: + return [dict(record) for record in self._rejection_records] + def _validate_template_contract(self, sample: CanonicalSample) -> None: if self._template_contract_validated: return @@ -414,6 +495,7 @@ def pack_preference_pairs_for_tq( __all__ = [ + "PreferenceDataError", "PreferencePair", "PreferenceStreamingDataset", "ProcessedPreferencePair", diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 1b3a68d45..963ce8c40 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -84,6 +84,9 @@ def validate_preference_args(args: Namespace) -> None: raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") if not getattr(args, "dpo_reference_free", False) and not getattr(args, "enable_weights_backuper", False): raise ValueError("standard DPO requires --enable-weights-backuper for actor/ref snapshots") + if not getattr(args, "dpo_reference_free", False): + if not getattr(args, "dpo_reference_repository", None) or not getattr(args, "dpo_reference_revision", None): + raise ValueError("standard DPO requires --dpo-reference-repository and --dpo-reference-revision") def sft_partition_id(args: Namespace, step: int) -> str: diff --git a/relax/utils/arguments.py b/relax/utils/arguments.py index 10af0fc52..176c7891b 100644 --- a/relax/utils/arguments.py +++ b/relax/utils/arguments.py @@ -477,6 +477,8 @@ def add_train_arguments(parser): parser.add_argument("--preference-chat-template-sha256", type=str, default=None) parser.add_argument("--preference-require-no-generation-marker", action="store_true", default=False) parser.add_argument("--dpo-beta", type=float, default=0.1) + parser.add_argument("--dpo-reference-repository", type=str, default=None) + parser.add_argument("--dpo-reference-revision", type=str, default=None) parser.add_argument( "--dpo-reference-free", action=argparse.BooleanOptionalAction, diff --git a/relax/utils/training/preference_utils.py b/relax/utils/training/preference_utils.py index 3df23f89b..3b4c2f96f 100644 --- a/relax/utils/training/preference_utils.py +++ b/relax/utils/training/preference_utils.py @@ -66,6 +66,43 @@ def dpo_pair_loss( return -F.logsigmoid(logits) +def build_preference_pair_indices( + branch_pair_ids: Sequence[int], branch_is_chosen: Sequence[bool] +) -> tuple[list[int], list[int]]: + """Return chosen/rejected branch indices grouped by stable pair + identity.""" + if len(branch_pair_ids) != len(branch_is_chosen): + raise ValueError( + "preference pair identity fields must be branch aligned: " + f"{len(branch_pair_ids)} vs {len(branch_is_chosen)}" + ) + if not branch_pair_ids: + raise ValueError("DPO micro-batch must contain at least one preference pair") + + pairs: dict[int, dict[bool, int]] = {} + order: list[int] = [] + for index, (raw_pair_id, raw_is_chosen) in enumerate(zip(branch_pair_ids, branch_is_chosen, strict=True)): + pair_id = int(raw_pair_id) + is_chosen = bool(raw_is_chosen) + if pair_id not in pairs: + pairs[pair_id] = {} + order.append(pair_id) + if is_chosen in pairs[pair_id]: + branch = "chosen" if is_chosen else "rejected" + raise ValueError(f"preference pair {pair_id!r} contains duplicate {branch} branches") + pairs[pair_id][is_chosen] = index + + chosen_indices: list[int] = [] + rejected_indices: list[int] = [] + for pair_id in order: + pair = pairs[pair_id] + if set(pair) != {False, True}: + raise ValueError(f"preference pair {pair_id!r} must contain exactly one chosen and one rejected branch") + chosen_indices.append(pair[True]) + rejected_indices.append(pair[False]) + return chosen_indices, rejected_indices + + def pack_preference_pair_indices( costs: Sequence[int], pair_ids: Sequence[str], @@ -106,6 +143,7 @@ def pack_preference_pair_indices( __all__ = [ + "build_preference_pair_indices", "build_causal_lm_labels", "dpo_pair_loss", "pack_preference_pair_indices", diff --git a/scripts/data/prepare_ultrafeedback_preferences.py b/scripts/data/prepare_ultrafeedback_preferences.py index 32dafd0c2..de8d5ad38 100644 --- a/scripts/data/prepare_ultrafeedback_preferences.py +++ b/scripts/data/prepare_ultrafeedback_preferences.py @@ -13,6 +13,23 @@ DATASET_ID = "HuggingFaceH4/ultrafeedback_binarized" DATASET_REVISION = "3949bf5f8c17c394422ccfab0c31ea9c20bdeb85" ORDER_NAMESPACE = "task31-ultrafeedback-v1:" +REJECTION_REASON_CODES = ( + "schema", + "identical", + "post_truncation", + "prompt_mismatch", + "empty_completion", + "oversize", +) + + +def _reason_code(error: BaseException) -> str: + message = str(error).lower() + if "identical" in message: + return "identical" + if "strict shared prompt" in message: + return "prompt_mismatch" + return "schema" def _sha256(path: Path) -> str: @@ -53,6 +70,7 @@ def _select(dataset, *, split: str, count: int) -> tuple[list[dict[str, Any]], l { "prompt_id": prompt_id, "source_index": index, + "reason_code": "schema", "reason": f"duplicate prompt_id in {split}; retained first source occurrence", } ) @@ -69,7 +87,14 @@ def _select(dataset, *, split: str, count: int) -> tuple[list[dict[str, Any]], l try: _validate_row(row, split=split, index=source_index) except ValueError as exc: - rejected.append({"prompt_id": prompt_id, "source_index": source_index, "reason": str(exc)}) + rejected.append( + { + "prompt_id": prompt_id, + "source_index": source_index, + "reason_code": _reason_code(exc), + "reason": str(exc), + } + ) continue selected.append( { @@ -141,6 +166,13 @@ def main() -> None: "train": train_rejections, "eval": eval_rejections, }, + "rejection_counts": { + split: { + reason_code: sum(item["reason_code"] == reason_code for item in rejections) + for reason_code in REJECTION_REASON_CODES + } + for split, rejections in (("train", train_rejections), ("eval", eval_rejections)) + }, }, "schema": { "prompt_id": "string", diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index f0cb38e01..6897294bc 100644 --- a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -27,6 +27,8 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --loss-type sft \ --sft-objective dpo \ --dpo-beta 0.1 \ + --dpo-reference-repository Qwen/Qwen3-0.6B \ + --dpo-reference-revision "${MODEL_REVISION}" \ --prompt-data "${PROMPT_DATA}" \ --input-key prompt \ --preference-pair-id-key prompt_id \ @@ -37,9 +39,10 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --hf-checkpoint "${HF_CHECKPOINT}" \ --ref-load "${HF_CHECKPOINT}" \ --megatron-to-hf-mode bridge \ + --enable-weights-backuper \ --save "${SAVE_DIR}/${EXP_NAME}" \ --load "${SAVE_DIR}/${EXP_NAME}" \ - --save-interval 50 \ + --save-interval "${SAVE_INTERVAL:-50}" \ --num-rollout "${NUM_ROLLOUT:-200}" \ --global-batch-size "${GLOBAL_BATCH_SIZE:-8}" \ --use-dynamic-batch-size \ @@ -51,6 +54,7 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --lr "${LR:-5e-7}" \ --lr-decay-style cosine \ --min-lr 0 \ + ${OVERRIDE_OPT_PARAM_SCHEDULER:+--override-opt-param-scheduler} \ --weight-decay 0.0 \ --clip-grad 1.0 \ --attention-dropout 0.0 \ diff --git a/tests/backends/megatron/test_dpo_loss.py b/tests/backends/megatron/test_dpo_loss.py new file mode 100644 index 000000000..0d38e14ce --- /dev/null +++ b/tests/backends/megatron/test_dpo_loss.py @@ -0,0 +1,139 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Production DPO loss regression tests.""" + +from argparse import Namespace + +import pytest +import torch +import torch.nn.functional as F + + +try: + from relax.backends.megatron import loss as loss_module +except Exception as exc: + pytest.skip(f"relax.backends.megatron unavailable: {exc}", allow_module_level=True) + + +def _args(*, reference_free: bool = False, beta: float = 0.2) -> Namespace: + return Namespace(dpo_reference_free=reference_free, dpo_beta=beta) + + +def _run(monkeypatch, policy_values, *, order=None, reference_free=False, ref_values=None, num_samples=2): + if order is None: + order = [0, 1, 2, 3] + pair_ids = [10, 10, 20, 20] + is_chosen = [True, False, True, False] + policy = [torch.as_tensor(policy_values[index]).reshape(1) for index in order] + reference = None if ref_values is None else [torch.as_tensor(ref_values[index]).reshape(1) for index in order] + monkeypatch.setattr( + loss_module, "get_log_probs_and_entropy", lambda *args, **kwargs: (None, {"log_probs": policy}) + ) + logits = torch.ones(1, requires_grad=True) + batch = { + "response_lengths": [1] * 4, + "unconcat_tokens": [torch.ones(1, dtype=torch.long)] * 4, + "total_lengths": [1] * 4, + "loss_masks": [torch.ones(1)] * 4, + "preference_branch_pair_ids": [pair_ids[index] for index in order], + "preference_is_chosen": [is_chosen[index] for index in order], + "ref_log_probs": reference, + "num_samples": num_samples, + } + return loss_module.dpo_loss_function(_args(reference_free=reference_free), batch, logits, lambda value: value) + + +def test_production_dpo_loss_matches_independent_reference_and_gradients(monkeypatch): + policy = torch.tensor([-1.0, -2.0, -0.5, -0.75], requires_grad=True) + reference = torch.tensor([-1.2, -1.7, -0.4, -0.8]) + actual, metrics = _run(monkeypatch, list(policy.unbind()), ref_values=list(reference.unbind())) + expected = -F.logsigmoid(0.2 * ((policy[0::2] - policy[1::2]) - (reference[0::2] - reference[1::2]))).sum() + torch.testing.assert_close(actual, expected) + actual.backward() + actual_grad = policy.grad.clone() + policy.grad = None + expected.backward() + torch.testing.assert_close(actual_grad, policy.grad) + assert { + "dpo_logps_chosen", + "dpo_logps_rejected", + "dpo_ref_logps_chosen", + "dpo_ref_logps_rejected", + "dpo_tie_rate", + "dpo_tie_aware_accuracy", + }.issubset(metrics) + + +def test_pair_identity_restores_reordered_micro_batch(monkeypatch): + policy = [-1.0, -2.0, -0.5, -0.75] + reference = [-1.2, -1.7, -0.4, -0.8] + baseline, baseline_metrics = _run(monkeypatch, policy, ref_values=reference) + reordered, reordered_metrics = _run(monkeypatch, policy, ref_values=reference, order=[3, 0, 2, 1]) + torch.testing.assert_close(reordered, baseline) + for key in baseline_metrics: + torch.testing.assert_close(reordered_metrics[key], baseline_metrics[key]) + + +def test_tie_metrics_are_epsilon_aware(monkeypatch): + _, metrics = _run( + monkeypatch, + [-1.0, -2.0, -0.5, -0.75], + ref_values=[-1.0, -2.0, -0.5, -0.75], + ) + assert metrics["dpo_strict_accuracy"].item() == 0 + assert metrics["dpo_tie_rate"].item() == 2 + assert metrics["dpo_tie_aware_accuracy"].item() == 1 + + +def test_reference_free_partition_and_num_samples_do_not_change_pair_sum(monkeypatch): + policy = [-1.0, -2.0, -0.5, -0.75] + first, _ = _run(monkeypatch, policy, reference_free=True, num_samples=1) + second, _ = _run(monkeypatch, policy, reference_free=True, num_samples=999) + torch.testing.assert_close(first, second) + pair_losses = -F.logsigmoid(0.2 * (torch.tensor(policy)[0::2] - torch.tensor(policy)[1::2])) + torch.testing.assert_close(first, pair_losses[:1].sum() + pair_losses[1:].sum()) + + +@pytest.mark.parametrize( + ("pair_ids", "chosen", "match"), + [ + ([1, 1, 2, 2], [True, True, True, False], "duplicate chosen"), + ([1, 2, 2, 3], [True, True, False, False], "exactly one"), + ], +) +def test_production_dpo_rejects_invalid_pair_identity(monkeypatch, pair_ids, chosen, match): + monkeypatch.setattr( + loss_module, + "get_log_probs_and_entropy", + lambda *args, **kwargs: (None, {"log_probs": [torch.zeros(1) for _ in pair_ids]}), + ) + batch = { + "response_lengths": [1] * len(pair_ids), + "unconcat_tokens": [torch.ones(1, dtype=torch.long)] * len(pair_ids), + "total_lengths": [1] * len(pair_ids), + "loss_masks": [torch.ones(1)] * len(pair_ids), + "preference_branch_pair_ids": pair_ids, + "preference_is_chosen": chosen, + "ref_log_probs": [torch.zeros(1) for _ in pair_ids], + } + with pytest.raises(ValueError, match=match): + loss_module.dpo_loss_function(_args(), batch, torch.ones(1), lambda value: value) + + +def test_production_dpo_rejects_empty_completion_mask(monkeypatch): + monkeypatch.setattr( + loss_module, + "get_log_probs_and_entropy", + lambda *args, **kwargs: (None, {"log_probs": [torch.zeros(1), torch.zeros(1)]}), + ) + batch = { + "response_lengths": [1, 1], + "unconcat_tokens": [torch.ones(1, dtype=torch.long)] * 2, + "total_lengths": [1, 1], + "loss_masks": [torch.zeros(1), torch.ones(1)], + "preference_branch_pair_ids": [1, 1], + "preference_is_chosen": [True, False], + "ref_log_probs": [torch.zeros(1), torch.zeros(1)], + } + with pytest.raises(ValueError, match="at least one supervised token"): + loss_module.dpo_loss_function(_args(), batch, torch.ones(1), lambda value: value) diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py new file mode 100644 index 000000000..bb76a10fc --- /dev/null +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -0,0 +1,177 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Frozen-reference checksum, probe, optimizer and sidecar tests.""" + +import json +from argparse import Namespace + +import pytest +import torch + +from relax.backends.megatron.checkpoint import is_megatron_checkpoint +from relax.backends.megatron.reference_integrity import ( + DPOReferenceIdentity, + canonical_optimizer_sha256, + canonical_tensor_sha256, + read_reference_identity, + reference_probe_sha256, + write_reference_identity, +) + + +def test_megatron_resume_detection_ignores_fresh_output_directory(tmp_path): + output = tmp_path / "run" + output.mkdir() + (output / "transformer_config.json").write_text("{}", encoding="utf-8") + assert not is_megatron_checkpoint(output) + (output / "latest_checkpointed_iteration.txt").write_text("1", encoding="utf-8") + assert is_megatron_checkpoint(output) + assert is_megatron_checkpoint(tmp_path / "iter_0000001") + + +def test_canonical_tensor_digest_is_order_stable_and_byte_sensitive(): + first = canonical_tensor_sha256([("b", torch.tensor([2.0])), ("a", torch.tensor([1.0]))]) + reordered = canonical_tensor_sha256([("a", torch.tensor([1.0])), ("b", torch.tensor([2.0]))]) + changed = canonical_tensor_sha256([("a", torch.tensor([1.0])), ("b", torch.tensor([3.0]))]) + assert first == reordered + assert first != changed + assert first != canonical_tensor_sha256([("a", torch.tensor([1], dtype=torch.int64)), ("b", torch.tensor([2.0]))]) + + +def test_optimizer_digest_detects_master_or_state_changes(): + parameter = torch.nn.Parameter(torch.tensor([1.0])) + optimizer = torch.optim.Adam([parameter], lr=0.1) + (parameter.square().sum()).backward() + optimizer.step() + baseline = canonical_optimizer_sha256(optimizer) + master_value = parameter.detach().clone() + parameter.data.add_(1) + master_changed = canonical_optimizer_sha256(optimizer) + assert master_changed != baseline + parameter.data.copy_(master_value) + optimizer.state[parameter]["exp_avg"].add_(1) + assert canonical_optimizer_sha256(optimizer) != baseline + + +def test_probe_digest_covers_identity_tokens_masks_and_fp32_logprobs(): + args = ([1, 1], [True, False], [[1, 2], [1, 3]], [[0, 1], [0, 1]]) + baseline = reference_probe_sha256(*args, [[0.0, -1.0], [0.0, -2.0]]) + assert baseline != reference_probe_sha256(*args, [[0.0, -1.0], [0.0, -2.1]]) + assert baseline != reference_probe_sha256([2, 2], *args[1:], [[0.0, -1.0], [0.0, -2.0]]) + + +@pytest.mark.skipif(not torch.cuda.is_available(), reason="CUDA is required for cross-device probe coverage") +def test_probe_digest_accepts_gpu_logprobs_with_cpu_manifest(): + cpu_digest = reference_probe_sha256([1], [True], [[1, 2]], [[0, 1]], [[0.0, -1.0]]) + gpu_digest = reference_probe_sha256([1], [True], [[1, 2]], [[0, 1]], [torch.tensor([0.0, -1.0], device="cuda")]) + assert gpu_digest == cpu_digest + + +def test_reference_identity_sidecar_is_required_and_rejects_schema_damage(tmp_path): + path = tmp_path / "relax_dpo_reference.json" + with pytest.raises(FileNotFoundError): + read_reference_identity(path) + identity = DPOReferenceIdentity(1, "repo", "revision", "loader", "a" * 64, "b" * 64) + write_reference_identity(path, identity) + assert read_reference_identity(path) == identity + payload = identity.to_dict() + payload["schema_version"] = 99 + path.write_text(json.dumps(payload), encoding="utf-8") + with pytest.raises(ValueError, match="unsupported"): + read_reference_identity(path) + + +def test_resume_probe_materializes_manifest_lists_as_tensors(monkeypatch): + try: + from relax.backends.megatron import actor as actor_module + except Exception as exc: + pytest.skip(f"Megatron actor unavailable: {exc}") + + instance = object.__new__(actor_module.MegatronTrainRayActor) + instance.args = Namespace() + instance.model = [object()] + instance._dpo_reference_probe_verified = False + instance._expected_dpo_reference_identity = DPOReferenceIdentity( + 1, + "repo", + "revision", + "loader", + "a" * 64, + "b" * 64, + { + "pair_ids": [1, 1], + "branch_is_chosen": [True, False], + "tokens": [[1, 2], [1, 3]], + "loss_masks": [[False, True], [False, True]], + "total_lengths": [2, 2], + "response_lengths": [1, 1], + }, + ) + + def inspect_probe_data(_args, _model, probe_data): + assert all(torch.is_tensor(value) and value.dtype == torch.long for value in probe_data["tokens"]) + assert all(torch.is_tensor(value) and value.dtype == torch.bool for value in probe_data["loss_masks"]) + raise RuntimeError("probe inspected") + + monkeypatch.setattr(actor_module, "get_data_iterator", inspect_probe_data) + monkeypatch.setattr(actor_module.mpu, "get_data_parallel_world_size", lambda **_kwargs: 1) + monkeypatch.setattr(actor_module.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) + with pytest.raises(RuntimeError, match="probe inspected"): + instance._replay_dpo_reference_probe() + + +def test_loader_half_write_failure_restores_actor_and_keeps_optimizer(monkeypatch): + try: + from relax.backends.megatron import actor as actor_module + except Exception as exc: + pytest.skip(f"Megatron actor unavailable: {exc}") + + parameter = torch.nn.Parameter(torch.tensor([1.0])) + optimizer = torch.optim.Adam([parameter], lr=0.1) + + class _Backuper: + def __init__(self): + self.values = {"actor": {"weight": parameter.detach().clone()}} + + @property + def backup_tags(self): + return list(self.values) + + def restore(self, tag): + parameter.data.copy_(self.values[tag]["weight"]) + + def backup(self, tag): + self.values[tag] = {"weight": parameter.detach().clone()} + + def get(self, tag): + return self.values[tag] + + instance = object.__new__(actor_module.MegatronTrainRayActor) + instance.args = Namespace( + load="checkpoint", + no_load_optim=False, + no_load_rng=False, + finetune=False, + megatron_to_hf_mode="bridge", + dpo_reference_repository="repo", + dpo_reference_revision="revision", + ) + instance.model = [object()] + instance.optimizer = optimizer + instance.weights_backuper = _Backuper() + instance._active_model_tag = "actor" + instance._expected_dpo_reference_identity = None + monkeypatch.setattr(actor_module.device_utils, "maybe_backend_process_on_model_switch", lambda: None) + + def fail_after_half_write(*args, **kwargs): + parameter.data.fill_(99) + raise RuntimeError("injected loader failure") + + monkeypatch.setattr(actor_module, "load_checkpoint", fail_after_half_write) + before = canonical_optimizer_sha256(optimizer) + with pytest.raises(RuntimeError, match="injected loader failure"): + instance._rebuild_dpo_reference("hf-path") + assert parameter.item() == 1.0 + assert instance._active_model_tag == "actor" + assert "ref" not in instance.weights_backuper.backup_tags + assert canonical_optimizer_sha256(optimizer) == before diff --git a/tests/backends/megatron/test_preference_batching.py b/tests/backends/megatron/test_preference_batching.py new file mode 100644 index 000000000..dff225879 --- /dev/null +++ b/tests/backends/megatron/test_preference_batching.py @@ -0,0 +1,94 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Preference-row atomicity and dynamic batching tests.""" + +from argparse import Namespace + +import pytest +import torch + + +try: + from relax.backends.megatron import data as data_module + from relax.backends.megatron.data import expand_preference_rollout_data + from relax.utils.training.preference_utils import pack_preference_pair_indices +except Exception as exc: + pytest.skip(f"relax.backends.megatron unavailable: {exc}", allow_module_level=True) + + +def _pair_rows(count=2): + return { + "pair_ids": list(range(100, 100 + count)), + "chosen_tokens": [[1, 2]] * count, + "rejected_tokens": [[1, 3]] * count, + "chosen_loss_masks": [[0, 1]] * count, + "rejected_loss_masks": [[0, 1]] * count, + "chosen_total_lengths": [2] * count, + "rejected_total_lengths": [2] * count, + } + + +def test_expand_keeps_pairs_atomic_and_preserves_dynamic_denominator(): + rows = _pair_rows() + rows["dynamic_global_batch_size"] = 2 + flat = expand_preference_rollout_data(rows) + assert flat["dynamic_global_batch_size"] == 2 + assert flat["preference_branch_pair_ids"] == [100, 100, 101, 101] + assert flat["preference_is_chosen"] == [True, False, True, False] + assert flat["preference_pair_costs"] == [4, 4] + + +def test_capacity_packer_is_deterministic_complete_and_bounded(): + costs = [2, 4, 4, 5, 5] + first = pack_preference_pair_indices(costs, ["a", "b", "c", "d", "e"], capacity=10) + second = pack_preference_pair_indices(costs, ["a", "b", "c", "d", "e"], capacity=10) + assert first == second + assert sorted(index for group in first for index in group) == list(range(len(costs))) + assert all(sum(costs[index] for index in group) <= 10 for group in first) + + +def test_preference_iterator_validates_step_global_pair_denominator(monkeypatch): + flat = expand_preference_rollout_data(_pair_rows()) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_world_size", lambda **kwargs: 1) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_group", lambda: object()) + monkeypatch.setattr(data_module.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) + monkeypatch.setattr(data_module.dist, "all_reduce", lambda tensor, **kwargs: None) + args = Namespace(global_batch_size=2, max_tokens_per_gpu=16) + iterators, counts = data_module._get_preference_data_iterator(args, flat, None) + assert counts == [1] + assert flat["dynamic_global_batch_size"] == 2 + assert len(iterators) == 1 + + invalid = expand_preference_rollout_data(_pair_rows()) + invalid["dynamic_global_batch_size"] = 4 + with pytest.raises(ValueError, match="step-global preference pair count"): + data_module._get_preference_data_iterator(args, invalid, None) + + +def test_dp2_pair_rows_remain_atomic_with_global_pair_denominator(monkeypatch): + flat = expand_preference_rollout_data(_pair_rows()) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_world_size", lambda **kwargs: 2) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_group", lambda: object()) + monkeypatch.setattr(data_module.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) + + def all_reduce(tensor, *, op, **kwargs): + if op == data_module.dist.ReduceOp.SUM: + tensor.mul_(2) + + monkeypatch.setattr(data_module.dist, "all_reduce", all_reduce) + args = Namespace(global_batch_size=4, max_tokens_per_gpu=4) + iterators, counts = data_module._get_preference_data_iterator(args, flat, None) + assert flat["dynamic_global_batch_size"] == 4 + assert counts == [2] + seen = [] + for _ in range(counts[0]): + batch = iterators[0].get_next(["preference_branch_pair_ids", "preference_is_chosen"]) + assert len(set(batch["preference_branch_pair_ids"])) == 1 + assert set(batch["preference_is_chosen"]) == {False, True} + seen.extend(batch["preference_branch_pair_ids"]) + assert sorted(seen) == [100, 100, 101, 101] + + +def test_oversize_error_names_pair_cost_and_capacity(): + with pytest.raises(ValueError, match=r"oversize preference pair 'pair-x'.*cost 11, capacity=10"): + pack_preference_pair_indices([11], ["pair-x"], capacity=10) diff --git a/tests/engine/sft/dataset/test_preference.py b/tests/engine/sft/dataset/test_preference.py index 6fc704aa4..d67aadbc0 100644 --- a/tests/engine/sft/dataset/test_preference.py +++ b/tests/engine/sft/dataset/test_preference.py @@ -8,7 +8,11 @@ import pytest import torch -from relax.engine.sft.dataset.preference import PreferenceStreamingDataset, pack_preference_pairs_for_tq +from relax.engine.sft.dataset.preference import ( + PreferenceDataError, + PreferenceStreamingDataset, + pack_preference_pairs_for_tq, +) def _write_jsonl(path: Path, rows: list[dict]) -> None: @@ -115,6 +119,27 @@ def test_implicit_ultrafeedback_pair_extracts_strict_common_prefix(tmp_path: Pat assert pair.rejected_completion_length == 3 +def test_rejection_reason_is_classified_counted_and_still_fail_fast(tmp_path: Path): + path = tmp_path / "identical.jsonl" + _write_jsonl( + path, + [ + { + "prompt_id": "pair-identical", + "prompt": [{"role": "user", "content": "question"}], + "chosen": {"role": "assistant", "content": "same"}, + "rejected": {"role": "assistant", "content": "same"}, + } + ], + ) + dataset = _dataset(path) + with pytest.raises(PreferenceDataError) as exc_info: + dataset.get_processed_pair(0) + assert exc_info.value.reason_code == "identical" + assert dataset.rejection_counts == {"identical": 1} + assert dataset.rejection_records[0]["pair_id"] == "pair-identical" + + @pytest.mark.parametrize( ("update", "match"), [ diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index 37f781a37..236a0c6fd 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -35,6 +35,8 @@ def _args(**overrides) -> Namespace: "eval_size": None, "dpo_beta": 0.1, "dpo_reference_free": False, + "dpo_reference_repository": "Qwen/Qwen3-0.6B", + "dpo_reference_revision": "fixed-revision", "ref_update_interval": None, "enable_weights_backuper": True, "preference_max_length": 1024, @@ -75,3 +77,8 @@ def test_preference_validation_rejects_unsupported_configs(overrides: dict, matc def test_reference_free_dpo_does_not_require_ref_update_constraint(): validate_preference_args(_args(dpo_reference_free=True, ref_update_interval=10)) + + +def test_standard_dpo_requires_explicit_reference_repository_and_revision(): + with pytest.raises(ValueError, match="dpo-reference-repository"): + validate_preference_args(_args(dpo_reference_repository=None)) From f03aa5c6843cfbf7c782da4dae7fb6832be103de Mon Sep 17 00:00:00 2001 From: A-Words Date: Sat, 8 Aug 2026 03:38:30 +0800 Subject: [PATCH 03/25] fix(sft): complete DPO delivery contract --- docs/.vitepress/config.mts | 2 + docs/en/guide/dpo-training.md | 59 + docs/zh/guide/dpo-training.md | 59 + relax/backends/megatron/loss.py | 24 +- .../manifests/task31-ultrafeedback-v1.json | 4935 +++++++++++++++++ .../dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 2 +- tests/backends/megatron/test_dpo_loss.py | 18 +- .../megatron/test_preference_batching.py | 58 + 8 files changed, 5135 insertions(+), 22 deletions(-) create mode 100644 docs/en/guide/dpo-training.md create mode 100644 docs/zh/guide/dpo-training.md create mode 100644 scripts/data/manifests/task31-ultrafeedback-v1.json diff --git a/docs/.vitepress/config.mts b/docs/.vitepress/config.mts index 368ecb31c..5dbf68417 100644 --- a/docs/.vitepress/config.mts +++ b/docs/.vitepress/config.mts @@ -244,6 +244,7 @@ export default defineConfig({ { text: 'Quick Start', link: '/en/guide/quick-start' }, { text: 'Customize Training', link: '/en/guide/customize-training' }, { text: 'SFT Training', link: '/en/guide/sft-training' }, + { text: 'DPO Training', link: '/en/guide/dpo-training' }, { text: 'PPO Training', link: '/en/guide/ppo-training' }, { text: 'Model Checkpoint Conversion', link: '/en/guide/model-conversion' }, { text: 'Configuration', link: '/en/guide/configuration' } @@ -353,6 +354,7 @@ export default defineConfig({ { text: '快速上手', link: '/zh/guide/quick-start' }, { text: '自定义训练', link: '/zh/guide/customize-training' }, { text: 'SFT 训练', link: '/zh/guide/sft-training' }, + { text: 'DPO 训练', link: '/zh/guide/dpo-training' }, { text: 'PPO 训练', link: '/zh/guide/ppo-training' }, { text: '模型 Checkpoint 转换', link: '/zh/guide/model-conversion' }, { text: '配置说明', link: '/zh/guide/configuration' } diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md new file mode 100644 index 000000000..57ed315e8 --- /dev/null +++ b/docs/en/guide/dpo-training.md @@ -0,0 +1,59 @@ +# DPO Training + +Relax supports Direct Preference Optimization (DPO) through the offline SFT data path. The public Task 31 recipe is [`run-qwen3-0.6B-ultrafeedback-1xgpu.sh`](../../../scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh). + +## Prepare the preference subset + +Generate the deterministic UltraFeedback subset from its pinned dataset revision: + +```bash +python scripts/data/prepare_ultrafeedback_preferences.py \ + --output-dir /data/task31-ultrafeedback +``` + +The command creates train/eval JSONL and Parquet files plus `manifest.json`. Compare the generated manifest with the checked-in [`task31-ultrafeedback-v1.json`](../../../scripts/data/manifests/task31-ultrafeedback-v1.json) before training. The manifest fixes the source revision, selected prompt IDs, rejection counts, and output SHA-256 values. Derived dataset files are intentionally not stored in Git. + +Each input row contains one complete preference pair: + +```json +{ + "prompt_id": "stable-id", + "chosen": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}], + "rejected": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}] +} +``` + +Chosen and rejected branches must have an identical prompt and different, non-empty assistant completions. + +## Launch standard DPO + +Download the pinned Qwen checkpoint, then set the model, data, and output locations expected by the standard entrypoint: + +```bash +export MODEL_DIR=/models +export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet +export SAVE_DIR=/checkpoints/task31-dpo + +bash scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +``` + +The recipe defaults to 200 optimizer steps, 32 preference pairs per global batch, `beta=0.1`, and a 1,024-token branch limit. `GLOBAL_BATCH_SIZE`, `NUM_ROLLOUT`, `MAX_TOKENS_PER_GPU`, and `SAVE_INTERVAL` can be overridden explicitly. + +Standard DPO reconstructs the frozen reference from the pinned repository revision. Checkpoints include a reference-identity sidecar containing canonical parameter and fixed-probe digests. A missing or mismatched sidecar fails before the next forward pass. + +Use `--dpo-reference-free` only when reference-free DPO is intended; do not combine it with the standard reference identity arguments. + +## Pair-aware batching + +One preference pair is one TransferQueue row. Its chosen and rejected branch lengths are combined into `custom_meta.total_lengths`; the pinned `SeqlenBalancedSampler` assigns complete rows and keeps equal pair counts across data-parallel ranks. Branches are expanded only after a rank receives its rows, so dynamic micro-batch reordering cannot split pair identity. + +## Metrics + +DPO emits the following training metrics under the `train/dpo/` namespace: + +- `loss`, `logps_chosen`, and `logps_rejected`; +- `ref_logps_chosen` and `ref_logps_rejected` in standard mode; +- `reward_chosen`, `reward_rejected`, and `reward_margin`; +- `strict_accuracy`, `tie_rate`, and `tie_aware_accuracy`. + +For distributed parity claims, run DP=1 and DP=2 with the same image, model/data revisions, hyperparameters, and batch semantics, and retain the raw logs and reference digests. diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md new file mode 100644 index 000000000..c1e536a4f --- /dev/null +++ b/docs/zh/guide/dpo-training.md @@ -0,0 +1,59 @@ +# DPO 训练 + +Relax 通过离线 SFT 数据链路支持 Direct Preference Optimization（DPO）。Task 31 的公开 recipe 是 [`run-qwen3-0.6B-ultrafeedback-1xgpu.sh`](../../../scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh)。 + +## 准备偏好数据子集 + +从固定的数据集 revision 生成确定性的 UltraFeedback 子集： + +```bash +python scripts/data/prepare_ultrafeedback_preferences.py \ + --output-dir /data/task31-ultrafeedback +``` + +命令会生成 train/eval JSONL、Parquet 以及 `manifest.json`。训练前应将生成结果与仓库中的 [`task31-ultrafeedback-v1.json`](../../../scripts/data/manifests/task31-ultrafeedback-v1.json) 对比。manifest 固定 source revision、选中的 prompt ID、拒绝原因计数和输出文件 SHA-256；派生数据文件本身不提交到 Git。 + +每行输入承载一个完整 preference pair： + +```json +{ + "prompt_id": "stable-id", + "chosen": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}], + "rejected": [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}] +} +``` + +chosen/rejected 必须共享完全相同的 prompt，并包含不同且非空的 assistant completion。 + +## 启动标准 DPO + +下载固定版本的 Qwen checkpoint，然后设置标准入口所需的模型、数据和输出路径： + +```bash +export MODEL_DIR=/models +export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet +export SAVE_DIR=/checkpoints/task31-dpo + +bash scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +``` + +recipe 默认运行 200 个 optimizer step，每个 global batch 为 32 个 preference pair，`beta=0.1`，单分支最大 1,024 token。可以显式覆盖 `GLOBAL_BATCH_SIZE`、`NUM_ROLLOUT`、`MAX_TOKENS_PER_GPU` 和 `SAVE_INTERVAL`。 + +标准 DPO 会从固定 repository revision 重建冻结 reference。checkpoint 带有 reference identity sidecar，其中保存 canonical parameter digest 和固定 probe digest；sidecar 缺失或不一致时，会在下一次 forward 前失败。 + +只有明确需要 reference-free DPO 时才使用 `--dpo-reference-free`，不要同时传入标准 reference identity 参数。 + +## Pair-aware batching + +一个 preference pair 对应一个 TransferQueue row。chosen/rejected 分支长度相加后写入 `custom_meta.total_lengths`；固定版本的 `SeqlenBalancedSampler` 分配完整 row，并保证各 data-parallel rank 的 pair 数相同。只有 rank 收到 pair row 后才展开两个分支，因此动态 micro-batch 重排不会破坏 pair identity。 + +## 指标 + +DPO 在 `train/dpo/` 命名空间下记录以下训练指标： + +- `loss`、`logps_chosen` 和 `logps_rejected`； +- 标准模式下的 `ref_logps_chosen` 和 `ref_logps_rejected`； +- `reward_chosen`、`reward_rejected` 和 `reward_margin`； +- `strict_accuracy`、`tie_rate` 和 `tie_aware_accuracy`。 + +如需声明分布式一致性，应在相同镜像、模型/数据 revision、超参数和 batch 语义下分别运行 DP=1、DP=2，并保留原始日志与 reference digest。 diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 8ff05f826..1b7af9eea 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -1262,20 +1262,20 @@ def sequence_sums(token_values) -> torch.Tensor: strict = reward_margin > 0 correct = reward_margin > 1e-6 metrics = { - "loss": pair_losses.detach().sum(), - "dpo_logps_chosen": policy_chosen.detach().sum(), - "dpo_logps_rejected": policy_rejected.detach().sum(), - "dpo_chosen_reward": chosen_rewards.detach().sum(), - "dpo_rejected_reward": rejected_rewards.detach().sum(), - "dpo_reward_margin": reward_margin.detach().sum(), - "dpo_strict_accuracy": strict.to(torch.float32).detach().sum(), - "dpo_tie_rate": tie.to(torch.float32).detach().sum(), - "dpo_tie_aware_accuracy": (correct.to(torch.float32) + 0.5 * tie.to(torch.float32)).detach().sum(), + "dpo/loss": pair_losses.detach().sum(), + "dpo/logps_chosen": policy_chosen.detach().sum(), + "dpo/logps_rejected": policy_rejected.detach().sum(), + "dpo/reward_chosen": chosen_rewards.detach().sum(), + "dpo/reward_rejected": rejected_rewards.detach().sum(), + "dpo/reward_margin": reward_margin.detach().sum(), + "dpo/strict_accuracy": strict.to(torch.float32).detach().sum(), + "dpo/tie_rate": tie.to(torch.float32).detach().sum(), + "dpo/tie_aware_accuracy": (correct.to(torch.float32) + 0.5 * tie.to(torch.float32)).detach().sum(), } - metrics["dpo_pair_accuracy"] = metrics["dpo_strict_accuracy"] + metrics["dpo/pair_accuracy"] = metrics["dpo/strict_accuracy"] if not reference_free: - metrics["dpo_ref_logps_chosen"] = reference_chosen.detach().sum() - metrics["dpo_ref_logps_rejected"] = reference_rejected.detach().sum() + metrics["dpo/ref_logps_chosen"] = reference_chosen.detach().sum() + metrics["dpo/ref_logps_rejected"] = reference_rejected.detach().sum() return loss, metrics diff --git a/scripts/data/manifests/task31-ultrafeedback-v1.json b/scripts/data/manifests/task31-ultrafeedback-v1.json new file mode 100644 index 000000000..a2f362736 --- /dev/null +++ b/scripts/data/manifests/task31-ultrafeedback-v1.json @@ -0,0 +1,4935 @@ +{ + "schema_version": 1, + "source": { + "dataset": "HuggingFaceH4/ultrafeedback_binarized", + "revision": "3949bf5f8c17c394422ccfab0c31ea9c20bdeb85" + }, + "selection": { + "algorithm": "sha256(\"task31-ultrafeedback-v1:\" + prompt_id), then first valid rows", + "overlap_count": 0, + "rejections": { + "train": [ + { + "prompt_id": "e0d5c29c0edd76dc914858b042cc7ad284bdd8d1c18d58031d7fadeeb8e7703b", + "source_index": 20867, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "11d6c4bc1cc418a7b4442bc0cac8395177af553c2db0cc85abf92f4b7e9bf483", + "source_index": 24752, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "b595feb9abc1b540a42bb114f9eba8d7081bcc70cc152825dd09132ddc937398", + "source_index": 24953, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "f615c8be47948f2c9b9259258548b21026eab4e50ebbbb09c66755d903ddd38c", + "source_index": 34634, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "b7629fd2f157be5e46b5ae723c1365b822afc0256006bd6223372e7d91cded9d", + "source_index": 40706, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "7adae33b7aebccf88c3bca7e21bf31b98348d83eacbd2601bc4b9799c329a537", + "source_index": 47859, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "a15036007a80e53f0da38479ac96e41e6523dbf42e4a61d4fc086132ead04ea9", + "source_index": 53899, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "99bb0c8259bf735d42012761366691a28574a809c610d35e358a22908b717301", + "source_index": 56843, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "bce3c7a3d96f7b3b456eb3c48cf1a955bfb2d75a899b5cd4eab59ea9c86f5213", + "source_index": 58479, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "2086d798828c3e96980fbac081a41de6fad0ba8639a95a9860805b1a75a47dd6", + "source_index": 58941, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "d7dad88bee4fc3743973607c73560feb664ee9086d85acd9648827363c12f19d", + "source_index": 59772, + "reason_code": "schema", + "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" + }, + { + "prompt_id": "b529d9f22b9e20a2ae86ceb85aab4adefa891c53393c4d96376b9c470a5f20f6", + "source_index": 3049, + "reason_code": "identical", + "reason": "train_prefs[3049] b529d9f22b9e20a2ae86ceb85aab4adefa891c53393c4d96376b9c470a5f20f6 has identical chosen/rejected branches" + }, + { + "prompt_id": "c36f89802b9a6e409f7cb6c6bbbc604fb7e21eed21ded0209e95ab1e02c0d860", + "source_index": 53004, + "reason_code": "identical", + "reason": "train_prefs[53004] c36f89802b9a6e409f7cb6c6bbbc604fb7e21eed21ded0209e95ab1e02c0d860 has identical chosen/rejected branches" + }, + { + "prompt_id": "76d8c6cce268ce52d2b91f8468bd0bd18d6c06191febd7a8209ca32279869c42", + "source_index": 7622, + "reason_code": "identical", + "reason": "train_prefs[7622] 76d8c6cce268ce52d2b91f8468bd0bd18d6c06191febd7a8209ca32279869c42 has identical chosen/rejected branches" + }, + { + "prompt_id": "8cbf4c09a767d8636d4a4524edef6b1a9e22958f1dc18b7a02dc2525eaaa99e7", + "source_index": 22328, + "reason_code": "identical", + "reason": "train_prefs[22328] 8cbf4c09a767d8636d4a4524edef6b1a9e22958f1dc18b7a02dc2525eaaa99e7 has identical chosen/rejected branches" + }, + { + "prompt_id": "16432b9a6418d11883e2f960338e952ef84f9e75d9272e6fb9f4710ee751510f", + "source_index": 31510, + "reason_code": "identical", + "reason": "train_prefs[31510] 16432b9a6418d11883e2f960338e952ef84f9e75d9272e6fb9f4710ee751510f has identical chosen/rejected branches" + }, + { + "prompt_id": "c547355999a455228daeb3240481df1a1aeaecbbcb7cbe2c7443a5ef49ca9d80", + "source_index": 5772, + "reason_code": "identical", + "reason": "train_prefs[5772] c547355999a455228daeb3240481df1a1aeaecbbcb7cbe2c7443a5ef49ca9d80 has identical chosen/rejected branches" + }, + { + "prompt_id": "04fcfcffdaf695a5e565a45d5fbcf0152a2404d7862ebe4a5201e67326601489", + "source_index": 777, + "reason_code": "identical", + "reason": "train_prefs[777] 04fcfcffdaf695a5e565a45d5fbcf0152a2404d7862ebe4a5201e67326601489 has identical chosen/rejected branches" + }, + { + "prompt_id": "25b8aee2ae3e7b1724b688004292f0fdc311de02f73e0665e9602518daf9df26", + "source_index": 5754, + "reason_code": "identical", + "reason": "train_prefs[5754] 25b8aee2ae3e7b1724b688004292f0fdc311de02f73e0665e9602518daf9df26 has identical chosen/rejected branches" + }, + { + "prompt_id": "1db02d009e337a429b40b0664a6284f8a7f08dc4748daeef16bef0a9bd5d7aba", + "source_index": 43539, + "reason_code": "identical", + "reason": "train_prefs[43539] 1db02d009e337a429b40b0664a6284f8a7f08dc4748daeef16bef0a9bd5d7aba has identical chosen/rejected branches" + }, + { + "prompt_id": "2ff4f1a417a8a0d591fd674de4057be32857b155abe153b7c449b7d06b0825f2", + "source_index": 42240, + "reason_code": "identical", + "reason": "train_prefs[42240] 2ff4f1a417a8a0d591fd674de4057be32857b155abe153b7c449b7d06b0825f2 has identical chosen/rejected branches" + }, + { + "prompt_id": "412cb9a3380617aec25f7b6bfcb72639bd7f2b95d7253f1ae16c251fb56c10ad", + "source_index": 17860, + "reason_code": "identical", + "reason": "train_prefs[17860] 412cb9a3380617aec25f7b6bfcb72639bd7f2b95d7253f1ae16c251fb56c10ad has identical chosen/rejected branches" + }, + { + "prompt_id": "32401dc887bd849c5142ad83047e2e08b3a052931912c84ad40f1f2673778073", + "source_index": 14172, + "reason_code": "identical", + "reason": "train_prefs[14172] 32401dc887bd849c5142ad83047e2e08b3a052931912c84ad40f1f2673778073 has identical chosen/rejected branches" + }, + { + "prompt_id": "1eed0101190708dcf85ceab84e172e2ac4fb3410d735f9b46c3c54d419d17a17", + "source_index": 34427, + "reason_code": "identical", + "reason": "train_prefs[34427] 1eed0101190708dcf85ceab84e172e2ac4fb3410d735f9b46c3c54d419d17a17 has identical chosen/rejected branches" + }, + { + "prompt_id": "cceba8a82cbb7af27536a6fc8ef271a3ad241cbb8d33744ccd431268ec4f7b44", + "source_index": 42736, + "reason_code": "identical", + "reason": "train_prefs[42736] cceba8a82cbb7af27536a6fc8ef271a3ad241cbb8d33744ccd431268ec4f7b44 has identical chosen/rejected branches" + }, + { + "prompt_id": "86bf719244d3172e178fc912fe53332772a9e7a73c178029448c095db1c4f3ea", + "source_index": 18838, + "reason_code": "identical", + "reason": "train_prefs[18838] 86bf719244d3172e178fc912fe53332772a9e7a73c178029448c095db1c4f3ea has identical chosen/rejected branches" + }, + { + "prompt_id": "f898f62951a72f0dc258dfe48e55f7576fc0c9a7392a286eeeb031642e573ec2", + "source_index": 47012, + "reason_code": "identical", + "reason": "train_prefs[47012] f898f62951a72f0dc258dfe48e55f7576fc0c9a7392a286eeeb031642e573ec2 has identical chosen/rejected branches" + }, + { + "prompt_id": "201e1580ad7df831ca43c86a5dcfc4dba5e2a0a9a111d884c161002b8c1f9003", + "source_index": 4697, + "reason_code": "identical", + "reason": "train_prefs[4697] 201e1580ad7df831ca43c86a5dcfc4dba5e2a0a9a111d884c161002b8c1f9003 has identical chosen/rejected branches" + }, + { + "prompt_id": "157aaa1fc8f6991010ce3e2b3e702138300b671d369d2bac84dd8d8bfcf90e0c", + "source_index": 23643, + "reason_code": "identical", + "reason": "train_prefs[23643] 157aaa1fc8f6991010ce3e2b3e702138300b671d369d2bac84dd8d8bfcf90e0c has identical chosen/rejected branches" + }, + { + "prompt_id": "921ade505b9cd43dcca36606a210e9d453e9cf84c956b04d3a456cc1e02e4d06", + "source_index": 10792, + "reason_code": "identical", + "reason": "train_prefs[10792] 921ade505b9cd43dcca36606a210e9d453e9cf84c956b04d3a456cc1e02e4d06 has identical chosen/rejected branches" + }, + { + "prompt_id": "b7054e29998d7c71639bef93bf6f4470f945fad2e77b3f5b8225e54118f08093", + "source_index": 3449, + "reason_code": "identical", + "reason": "train_prefs[3449] b7054e29998d7c71639bef93bf6f4470f945fad2e77b3f5b8225e54118f08093 has identical chosen/rejected branches" + }, + { + "prompt_id": "a60b7ee1ad5b7ac8a556a45e14f10a1efc83e931246a7323373f848d4ab2b0b6", + "source_index": 12733, + "reason_code": "identical", + "reason": "train_prefs[12733] a60b7ee1ad5b7ac8a556a45e14f10a1efc83e931246a7323373f848d4ab2b0b6 has identical chosen/rejected branches" + }, + { + "prompt_id": "1d6c3dbf86bf086c16f3093c240ab576c36d195bb01a4d5802029e3f0d7741f9", + "source_index": 550, + "reason_code": "identical", + "reason": "train_prefs[550] 1d6c3dbf86bf086c16f3093c240ab576c36d195bb01a4d5802029e3f0d7741f9 has identical chosen/rejected branches" + }, + { + "prompt_id": "6c50566bf1bec299ba13416025c72a5e648c5bf381314bdbf33ec6c9c650db3b", + "source_index": 31678, + "reason_code": "identical", + "reason": "train_prefs[31678] 6c50566bf1bec299ba13416025c72a5e648c5bf381314bdbf33ec6c9c650db3b has identical chosen/rejected branches" + }, + { + "prompt_id": "aff4fda268493547926e4c37433f3bc2fa2b224ee424241c0df7382866c50bb3", + "source_index": 48282, + "reason_code": "identical", + "reason": "train_prefs[48282] aff4fda268493547926e4c37433f3bc2fa2b224ee424241c0df7382866c50bb3 has identical chosen/rejected branches" + }, + { + "prompt_id": "927e525af2bffb5051c4033705bce8316269db204b199010b18e92c23d2136be", + "source_index": 9687, + "reason_code": "identical", + "reason": "train_prefs[9687] 927e525af2bffb5051c4033705bce8316269db204b199010b18e92c23d2136be has identical chosen/rejected branches" + }, + { + "prompt_id": "9facc8c570fcf678e70fbabebfdc9d83a5c1248ee6c4b6256febc8cee8fca7b8", + "source_index": 3123, + "reason_code": "identical", + "reason": "train_prefs[3123] 9facc8c570fcf678e70fbabebfdc9d83a5c1248ee6c4b6256febc8cee8fca7b8 has identical chosen/rejected branches" + }, + { + "prompt_id": "445425234596b1a264e90e6a59a022719308cca3af9d81a6113630eea960b46c", + "source_index": 11818, + "reason_code": "identical", + "reason": "train_prefs[11818] 445425234596b1a264e90e6a59a022719308cca3af9d81a6113630eea960b46c has identical chosen/rejected branches" + } + ], + "eval": [ + { + "prompt_id": "2bb3ce67227fd80e1ac019d18b44a32c5055eca1265b4d26f1a8dff15a8a104c", + "source_index": 9, + "reason_code": "identical", + "reason": "test_prefs[9] 2bb3ce67227fd80e1ac019d18b44a32c5055eca1265b4d26f1a8dff15a8a104c has identical chosen/rejected branches" + }, + { + "prompt_id": "a28191636d9e42835cbb0a4e8f478ef738a08d54e12f8eb404db48f94f453f9f", + "source_index": 1165, + "reason_code": "identical", + "reason": "test_prefs[1165] a28191636d9e42835cbb0a4e8f478ef738a08d54e12f8eb404db48f94f453f9f has identical chosen/rejected branches" + }, + { + "prompt_id": "21f5d5d038122239cf01baee9857c2906a60b146f41d5c03b7a20be1331a195e", + "source_index": 1561, + "reason_code": "identical", + "reason": "test_prefs[1561] 21f5d5d038122239cf01baee9857c2906a60b146f41d5c03b7a20be1331a195e has identical chosen/rejected branches" + }, + { + "prompt_id": "b49e32630ce6a19e4239b85a84be324d0af2dde3276f2e716df64e6cf76ce6dd", + "source_index": 1907, + "reason_code": "identical", + "reason": "test_prefs[1907] b49e32630ce6a19e4239b85a84be324d0af2dde3276f2e716df64e6cf76ce6dd has identical chosen/rejected branches" + }, + { + "prompt_id": "14f69be4f65cbb5ed352ecedd50a1992fb657f09eed4a128dddadb023637d53a", + "source_index": 282, + "reason_code": "identical", + "reason": "test_prefs[282] 14f69be4f65cbb5ed352ecedd50a1992fb657f09eed4a128dddadb023637d53a has identical chosen/rejected branches" + } + ] + }, + "rejection_counts": { + "train": { + "schema": 11, + "identical": 27, + "post_truncation": 0, + "prompt_mismatch": 0, + "empty_completion": 0, + "oversize": 0 + }, + "eval": { + "schema": 0, + "identical": 5, + "post_truncation": 0, + "prompt_mismatch": 0, + "empty_completion": 0, + "oversize": 0 + } + } + }, + "schema": { + "prompt_id": "string", + "chosen": "list<{role:string,content:string}>", + "rejected": "list<{role:string,content:string}>", + "metadata": "object" + }, + "outputs": { + "train": { + "count": 4096, + "prompt_ids": [ + "7c7105310e40a86f7e22f15380a3f58cbd10c6d38e05aed5e2bc38ff4d5a84c7", + "587722be0b4fc848404673f40c195db6fc5fe59fe2eed2d63fb0de11c331b48c", + "61fec5e5b0f24fca0d915b011c756ea935fe7a09dd6d04238594e23fabf2595f", + "8e550e61009782ca8b2de412fd84ca7d9c8bdfff090cc74b8ebd82008ffd2b43", + "9983eca4193dc79b9db1672e3945ad06eca2ef4a5dd98f384ba0ac1963c71494", + "1e9cc438558e6d2b09d821ed4e810decabd798f21ef9e367735afe2f8be47817", + "75202da83d77fb6d851ada882662d1ecdbfce179d5f780d1c1a7352f84afa12c", + "f86744852e0c80522f0910c2936231000b301ee6d277273a6ba5eb3b08aab81c", + "f13defc62d1b53d988751ba36737feb3990bad65bbc7496d21f71b2b6660fe57", + "cf9d345c9a0138e4f1c1b85b55647b479b38a98a4447d9f14346141676e3693f", + "95c4c02102f069fd1e6fc81a6ac44e06b14fe4a955713980a68e0f2c273e4446", + "254b5575483814583450de2027844cc4a3b2d5a8a749ef018ca5eca6cc98527a", + "a9a17c14f07c34f2db1224da2d668f9433c1bc6a077a8356d126558a13008e7c", + "14260157596b1ebb21f2fb95c942257a21f0ec27f757bbfea0fd1666f6d9b5bd", + "2f9a943dbaf31b0b028185c2344411464bd7e56e34aff7d5e757c091f280a2fe", + "7f2c49f7b56c6a1c0e5e17053ea8760f3ec385280d96f4ddba460d3e6e133636", + "9ed9b2cbd986a859b045a9c7b319f81ecb70f6a7387cc21c51e4b6364290363b", + "3eb6c7b88500a34fa3f151bd84cf4844b4ecb2c411dead407f428d9b6286a7fd", + "a72822bd7dfb48db2a09f3f429c0dd28f360d9ddfba5a6b5e43301ed321c7fb3", + "4f2932a1c71174f2e791f1a1ae72e1f7d401a9a56c4ee0b225d2fc1025926072", + "161e2c55baef98626b177628721ed902698fe602cc770515cc67d4d674e07af2", + "736f26744a2e6fd0fb5e3da906468104311597ca00d0d833a2185b700d043f09", + "7f7471f0810382846d124236d79a24062545eebf5c89c260075fc05e447ac034", + "af3a9a72ad0618a48493f4e5b0a1618b719b0585ba4f1f597695f7aa18c84b9f", + "c38d7b671df06604360da9471f1a70b32cefe26e0a9328bb04fcad9a049b0ff5", + "e60733a16b59ec6c8c7654543201cf042c615efd6833c0eee8745b4cef585dde", + "67707cc5e3cba2dba4c28f58655b5fd863247d671c1515fd58cc3dd6f1353a5e", + "80bad330999847e4a5228a7d9840699bd617ac7a42ae2b8262d6b376b24d2d3a", + "c09880583fdf41e5c63f24e15a5dbac283494162d3f1d7d9fb195ada8c50514a", + "2acf7ddfaba606653c268962d41accf85131caec820262eb9dcb4d26d7e6575d", + "9b3a4884e1d08b502d3e63b30ab1c693c78499d31f2bda5b10ca76bd3ac20276", + "791837eeea7a106a59070eaa92f2c1fd8b6f2c5158d9601fc8b5788180255657", + "f7edebc78b12af9afc8b758f6c5a13cf783f9e8b3bbcb74811758007ae757eac", + "50492f341b4f4ef07dc814a3806266b65814863a2558372cfce2b8653480ffeb", + "3e63b448fc16095b3257239266b05a4a0470283326695a81c81a7530790886c8", + "5dc45cb9ce20867501cca7fa4fdda71d22a8be9ecd93278e4a799ae65b8a711a", + "0b1ac4735c07ae49e8f649827fc2b4f32664eb51df833f28fb2acb4110451cf0", + "4ba3f063a5717f54c222205763c101de051362da8798d4e7be555c3232737218", + "151b9b1a995ed25fc5c25d9f2c2d4990f23c2bc6e34f5c282df93010ccd0a35c", + "b553cd4caada8c0bcb6d6d0245acbc2b011e1e96706b0284df13af809b201fc1", + "4a863997b824051ad0163551277aa83b80e9deba4bd2dfb73106591d685ec23e", + "65193c1dccdc005c4fd6d370b4ca9d3f7a5ef9b3eed826c4f6f70e011f05d712", + "c9fa0ac7e3b1bb0fd04a86a20b43cde4981a98efeec582b9f7ebd72af4c5f894", + "e0f2bc5dbdf8c169fbfad747738997e9358d982853b13faba9bdff0ba455b9a9", + "fd4f6eda8a71cab1ee2457f414acd4b7da81c19c0166e19d99cd2a8a1864da01", + "bb44e53204e087cd07fc779e2191a98db61b261d364562bfd01fc92f45061bf5", + "60d3fa35a2ad4985de2040b2e69fbd1a739e738d12f3e80aea67f52fc35ebe16", + "a246a283d6b47825eba20ab9812e7f9dcc39b8ea9c62311a7434a2cacc6ea68f", + "fcb299bdc5f652b62a85d2c978858822ad26e7e8d5998eeb4211e62c31ae655e", + "d0a6566367f07c3c87ac38b918954854cbff238c360d8e903186e73e5411ec31", + "ae113d002b53804b888243dab4d37308ce66df759479c8a42337b2e7f2956e4f", + "a689733f7da3bd4d3e10ea0bbbf86f574830883b985882f881f42a858011b64a", + "0542ed412ce22c3d777c20f052fd2138dbc4050d462685bb3203c175a1937598", + "06c30ebb780e53ecd3ee0e600ba0f1367754a4ff5da8776f286ae95e39d99e81", + "6be20e298c0f6e353d3c3b6b73c4afe6cef22503bf173edc5820c661e1ce94ee", + "341c88d3a929292b940ea0160230043f6215f5d430a946f7ace44d371c6490c2", + "7b15ffcec72a67543f6732c32cedef0a121385ce0adb27a2b3383c98bcaa61f4", + "14c451118150ed535769219f282e80c9c618d3036bc0dbbfa972fafc21738894", + "bf7f5a9d41124fd99f1a77329931cbcb6e5cc0afa2cb808fe2ff4ea7dd435aa9", + "35dcb596786e301651ed8365383329beb9f286b6e6d893e041038ec74c79e178", + "09354c81961faa9ff6eb4e8566d0b1796f4c331ae37237fe8e6dbb6a5f962600", + "1ee695e0e4bbcd6caa29af1f7afe7730e536d73d59cfd969d95c2d1dfce133a6", + "30bb25f0207b87ea4d2ebfa530142119d571dba3bd691430a812e77aa34ed33f", + "f6787e10836c26416732d8e3054226972a22e81be9ed433d9d7063becce03895", + "e263d7103241af9f76dc7479d105e0af5c08b6921b54318380c5ddda8384612e", + "2a57a86fef0884eb73bb3f00055bff908e9fad13081740b810a5489959b80829", + "cc4dfc42b97ef66ca7bd784e03291d6a5cb7bbe98f23a328bd8d1efe5870aac4", + "0fde786819b3d5b404032cb332b2729c8c37ce88e8196d99927c5d793444f98d", + "b3ee1aec0e62142bafd35261e23bdaeacea6a15cb0b38b0555f850086005da39", + "74418d34534fb1a1a5f7a80b41f93f503261d06f97072abd351179744f9c2bb3", + "8bde411486aa0ddb100f6d299894cbdaca1ea48e1639a31779a97b5526aad3ac", + "3d1918ca323a6275d50249b4e83486df31cf6fe12c311a2933184453e96381f0", + "47a995b8af40de50cda9ce986f01d380d121c78e821b8d9f493997f4966c1299", + "949f4571142b96bde370d874f18fa4765cdfb0bf3129ba9a3c51f795d3b0950d", + "01e4358043c7c611efd9783a08cdd648f0ff2fc3c11a9013b56d574bd215de48", + "f73779261e1a8a60e2aaa73dd2c879b8bb61615917fc198d3868cec64f91c6c0", + "f16fa88dcc645bd22c5ee44833190250ddf5f5f7098e85d14880f35ef55ffeef", + "d08083677213b848707dd91df5afc3f38ae35dab172d8a10413c561c82e13332", + "21923e9bc47ad7c6fbe04c40b3e923fd811b088cd1551aefd2b0cd4e1ddf5b88", + "98b64cd5690ec52b20f4acc07433ffe4aa609ea41c8b7ef993ee4517da772789", + "f710b66221ebb89ab2c8e865348d8b89117d4d9972e773e729f68afa4f8b7db7", + "c64861971fb3189b7acd266bfc1e7f7d58e3bac48f52ea63b1eae18139fc2b2e", + "a15823f4e2b458508b9904a4ac4bf6c0d29e038b463b557515b7ccb3e2c4ca7b", + "1848461113fec50144998b753a5765c4f3464b3c2ba8f65f95ecb356fadfcbc4", + "616158f1214ec4d8d1933e6b757a7eae15ffdb2322af6540150bcd608107e949", + "6d7b19129616c8bca24103f5e0b674ba80b00b0049d5ffc9b4840c4136bf390b", + "e6fa68a894ac3ef70f256eeae6f39f65e3940824e805d59ab994fd2d93604664", + "0eb7f9386272852a40486d1c83d9b7510a7ebdb657411b14a18ce60569ca35a1", + "6aea00608ae3c8e7b427ac2235e0c4a20db3ba89fcdabd6c80b56d280fa43a30", + "ee64241dcb088c0f58effa42464096ffbe504d37808a8a0ffb04b7b052078232", + "810758bd9054af32d971577f45f35c613abaa95068280c408bce7f598401813f", + "c4f3c31dff559a34a2261dddf2c32f4c41ed8a6251fd0e5d81145bb4e451e6ba", + "bf5891473793f5d2eb92111e9fbfdbafcb652f362af0d65fbe4dd43b2431c908", + "3f7930452bc846fed829a95e56a6fd918fb4687ad718dfea28a28be401f643ab", + "b8593779523369d85fd8b389e5d432d106c56e6c0875ec197284f2a8931e9447", + "d7e14588972e40c975fd66683c2cb1e35e5a9ffc9dd8d345f4f50c207aa9095d", + "7d1b47ee09b6d9659b2df77bf83ecdb7d5f7155c0f65ef705af5dd8ac7d946fe", + "3d34780cbd41f2eca6c6faa759ddb74b0d3135a866e7f60522cb57a7fc561e98", + "e1c1ba53e6c25a277536e5d6961bd1b08877880e904189a3878c89d34565cf4b", + "7723b17ea9f06c325dea75c92a450dbff9708e39f09cecf177a257674f46ba84", + "b619a608347df52cde1846566cde4d2c241df438acb9e305808be402412271b5", + "e4b5982e6ed747c31d09ae52a71ad1f3b1d5fd22e3563b3eefa068035fee3df0", + "a07f51328046d68db043697a3086f2388cdba6850affc0f6b64dbed2e6405f46", + "7c9c87d36adc1fd7fd29b1f83775efa38307a3a1b979a6714133e4050a3798a4", + "9567ce610e9428f9fdd00fe8cfe13b616612da826f9b6dae0ba710c026a31cb1", + "b9134494c9b399709a63bb3f563d11bd24a6c2ecf2a2e3c3346950cba7fad3da", + "44fe06d36cb7020b244e78fd957e913ac534e3233c945f7dd9850a89506da8ca", + "3b162aaaa189bae6a51546e1c8db5e3a72617c77a1fe65012ac2d1caf876517c", + "91ee83a49cca80c328c2ac2ae20b8063874520cf314721271da7c30492b9b0a4", + "07b9348499c93271e950029f3c2966b1b3fe1008d84754ab0406945c84e957c9", + "15a61604efd7be636f8b4cbd129f2d2891c685971e1277002d997f9ba6f68a8f", + "5097526a16fbb3f172a84f095058e2c57263ef9d77cf375b7a0bf5e75b20a4c0", + "4a64c2bb3ebb2323a60a2b30c3a96d82e6a6e88370dc5618a5f9c3b19e3edddf", + "ccb1223a401da915180d4225b63b190626f836cf1f301a649ec28c4f0f9f491e", + "f4bf04b33bd399f5cd55fd81793a0c8da9b6ef3596acd9f909a4934f734dcdfb", + "4ffa4779d94dc69db0e53a5f089cdc54b1883b2f426e14361b8bdd40ed3f9e49", + "1b40c1dcd8d3623a8ec886019f534072ca6419c9b06133f290e684d3227156e6", + "e1ccf1a4cb8629fc197516ff28fb82b524e5e44edc38c34376ff95d787f188a6", + "b576cc3f0f17477377147e049b5dee1a5fe8739418f0bf6d7ce58fb020ad04c5", + "3268f6d67c49cfef00a64157d2e63d675157946b113aee3fbcd0eb13056461a8", + "0c5c5a17f4409db135e35e76e4b767aad04e41dd01273ddd3a13061e12219979", + "8241abf9e891d61c2429592f61659c0773ce50fd8e5223996261f00c45b89294", + "e659b1ec4342949f5da5c9e64743bd280234dfae87af50416f3a349bf3a07854", + "699332d0569fbbc3a191e2157c2d29c186010003e5767fc252a28349ab08a06d", + "7e6c3a77b34ad9c97076a2cea14bcee8e29849a74dccf39312d2b892750bc206", + "3047eae1868aba494b19e1a06e1cc388b57b3a8835af9b5d063c410e2f4dcff3", + "f3e7f07b1ae70dfa6318abd54752c981254dd7d0caf759ff4367ed8f2eae93d8", + "016e9657886f0f66d5308dbda0721bc71133bb54d413ccf6c6dce39711520361", + "0507746785ea30f828f50eeda4d04e5f7e921328132e6f0625296081e8e5e995", + "6b434cbc61a560336d98a31bff3b03441a0e933750017543cd82c939794d73c1", + "224b2ebbae97b8d9129b50d3e65a0bf2ff5a6a01852d41a3d86103d28f23c7ca", + "4d198986f5318f1064829361cf10c6e60071145754c6477e6332c041b1fc6ba5", + "6bcf5b0e680e6c472e4c2cb227be9f78bdd192ef563a9a131ed6961d574024df", + "5b1f6d1e3d59275eccd1afb2ee3afe330caba743526ddcbabf0a0a8889d3eef6", + "2c5938307df0f35dfa95443e13bfb702a1d57faaa36f14a44ac284c3b58cbc5b", + "97e9d0c22de40c5123b9a70a5c099dfe5a23b18bb949864f880fc61fff6eccb5", + "ae5ace24064ac1995d79169852219427f215037a060138e7bd3f6e514c82bf64", + "a9528e9073b1a56bff3d1dd795c371eac8e69895a1b0ceb54c971933aed48022", + "1316d1438284c3b74b4d6acb42574c6cafa15d4a0505a7089f54e995cbdcbc61", + "158089622d8e1a09c4caa6f94534870d9ad8973cb68620f105d924f87f34c80d", + "b57bee7675313e5aea8714e7d3f08ddfacfff652fbb12ca2bf6d436ed1b09d2c", + "2fd92337e849cbb087367568031d35eaf384e9bcfb4927c4a1f1a97eca3aa803", + "332648dde35b3e55bf5660b88a9ed25feb979931bcefc7722ce426f703ff5718", + "0b5298a364440b9a150312c857dd077949034fac34ed4ecc69afdb8ce40a81f1", + "de433cdfbfe6befffb1982e599133c1ced7ad7d80b25b674d2a523d272cd76fb", + "0d40c2f8eb4bc17c11966bec324b49d6c59a628f0ee06d22ff142efedab2a285", + "2e7ee273e7ed85d88e98999ed1cc94e066d5ef08790f83072e009003b4584208", + "82e3f30c6dd8acfe396b10a6f501e28cc0ecddd54670c2e87301366b6c56d52c", + "b6f7aab052d159d45df6dc5a26e0ceee0932017fd421a7bf2432f316b2fb5cf7", + "855fa69be14315e1e99925bbe2d4d792279889b00ecc9b929e417f319526a3e6", + "196193e14b6978a29eb99c25f885c7f2b5fc8717582064f02ddf043cff9627e3", + "4d1bfa9cdbb1e8b076da712276021ee0e105b5809febaec21c427e3dbbac88fb", + "3deb8d19ccc993127328e1d44db7bac3365880a1f5cba5dc26ce2dc96e19eb7e", + "fc4b50091758bcb1106f33f32f7b96e86a9105e076db6b4c5964e22a2566a569", + "25b004c08b1b0f063d8352754a70ca870afcf0d4e6821807ff55f346844d4c83", + "6c5c21946be86c2b9d91e7d61347a6a0426378be39f53e39be2165a54efb3e4d", + "9fffa8349494047c5228f600b89d18b4e8eff557f785a78eca44e3cddd5601c8", + "8b3d737c8fc4400950571059613a270d21a8cbdc1a6de3c16bec2e7a6132d9cf", + "fc8c3300b5dc9ffbf0b8d07a8b9085734acf963bc246a8d6798849a15beb8425", + "26d8e108b39ee40a5f067028507ee5d82926fce23483b18b62ef24af6652d04f", + "92c18a135a4c7fec4528b3b4db5143b528015f689f1028a6a0083430f2fcf53a", + "b526a0f142d6ab28c33071375ca403ac2acaff82b07176f408bb59abfe0e7776", + "1c5e4c38bae002525a2866cf1de637d8243f2137ac3a325e0daf338c2e78c65b", + "7e7348c71675c9fd1d9a25abbe60f757a4a6aa381095cb76e3e5101b41ee4631", + "b57403314c67a853d04b80c66dd7084c20bbcdb564c20742cc31613c18ec0254", + "3ccb452c14d9af0b27ddd54d9b887002389a53e1a77be2ff8627d87e6a340a80", + "efb7914d387a84af466805f13aad1cc24ed43405ed6197e518d99a3f21331add", + "69f9d86cae40529ee787bcbbb9d0909670a99607475d57421f9636a84628fd14", + "1c7f7f217dae6ae33940fab8c7622404729e1839310dabd9c1f3a1b2b9e08abe", + "a645d5c9731c33726cc243c86abb065bf8dde833721e449c78a1b538cb3797a5", + "fa9cb6419efdf1a5e996fd048f02bf5d4bf67387b2b765329d23a0615df25d58", + "57a6018c00a89115f3d955d9b916e5c99ff87875653df3b645143ebf74c4a0b3", + "43c97af4afa4800ebadb93d8d1bde3f0f6bd1b013b5f8cafb5a6e1993222fd4f", + "789bba698641e563743bd52a7aa94372216bfa5251a6a3f1ce31be563d3d7ecd", + "c3a05b78c001623ac6a8fb1e8c357283001181c2a8e530f68c00648b6453b8f5", + "980936f5db0b77e860fe86b33997dae1a5d6b0c7f76108df73c65763162d146b", + "b740c8215268925a09d22e02c268a7e7098a6910f0d009abc73ce171bb52bc77", + "9497ac7a18fbdcea713d104b764e12d1cff188c46f3c92d57614da1b2648b024", + "3a55b7161285563826f79b4748b851b5765a246c6f6c9dfa564be18f52a58848", + "6deb624b2c9d526989ab36fa6f30719c979e7dbe3053d17b858c816bcc3a78f2", + "9490f3810403c8c3c92f2374aa3bd575d34f4aea667ee9a18dac17e884c6e2d2", + "c9004dd028ad614b7b72f02e72e685c06ec6e7f003aa5c903262527f59c7da47", + "fc4b9afe0d2d538ed7c8f949ca985d83eb36d6e012d653a637ece34719d0759e", + "39be9d9a53971e42294c04213cb5e0570d53af22e5112b075dd9216018621247", + "74ee16dc4daca37605bf7bc6e2c98f17619d88148f532c0804fb32285c71ee73", + "790d358ed205278ae9929e11a4d3b93fe336d3c702b4fecfc51866f4398f824c", + "42f356743e093d5ce36c9df88f1b0ae17c1506a19497a6808989964c2cdc4a53", + "945352c92420d79d846a50ef0e83d8c74cd4bc2fa8bba8d568face14069dc2c7", + "12739cef019d6ce849b478adde8acb2432b78bfaf0ea28ba30cac5024c606802", + "c42ea329ed78e0cf8e609011ca354d67e069386d7457874b4121e7cc704c06bb", + "91636ebf271adbd2d12150d272bf807cb3daecb42bd33592fb25d99a30aa2958", + "e4d6dd932c617866dd65fbb23655ad51e7a14e20d333bef0e7455d371f7b8569", + "c9a686ccd69833534d4a8c569d7f5bc2b6c2d2d18294e74338568c89d2b74de6", + "657ae0885ea75c53a98171dd21469a2a0c7c34fe6296cb47981ecb971cfaafd7", + "1f743e55136bce8a20b02d3566930209d725a7de408967a3d6b2b89c37c1f75d", + "db07a03776a6d54b1480002ca42cd5af48d3d4766bc675246999e0c51a3d7e5a", + "a0ced228cc95a728458c28a99884527848e48adf88012faa019480c9975d43fe", + "f5f116ad0b33926c4a0866853cea2152423a8d66c3843b7f4eddbed76f614a01", + "ceb2b40b3b769f184997d2e716e9910ea22a4aee85abd19ffc9867d531bd648d", + "7fb2a849df65e37542c7b1fe91297b0c8cd0efb7569280cc39eb68e19d386ea7", + "869192471bfac0c0be9c22c924474fd05711eeb72e4b4d3d096a72ae5a790355", + "7a31cb46babd5dd92b23ae7125fffa12528d2c0ccaa9d869d867ace747f2058e", + "29545efe39825c4023ef90aa1e6d4701b4511c32d7df51a3472a9e67b22e7788", + "3eb8d93e1390e710d539bd825ed17707724c339627509c26464607ad515e1569", + "70b653a722cf7909fa37fa677c287bb0ab8bc867030d87fe0da57ab42b71abec", + "1c547577c73d3ad9a6b214e8523e58c94c24c9defd50d3758ed99f9310b7dfc0", + "686b7b9eb0da1359855c46a91c2b8f591420eb5096e9f1a20edc4c07755a829c", + "edb2aa7753514f43603a3a7c57fb57f045c73ca2c9d5386a2b1f9d7cf4f366d6", + "41794f9ab241ec4a618f8081d9086ce0e3ce8a5fb37b6f210b69e3bab95729a9", + "084591e3f824d19f72a099b1b3b5cf9d944dd3e5c79a2c3ad35dd8b933c83c66", + "a17c1fe12ee03d373ec629cf5f5abeabb0a863f48503bf53483e97a6259a2fae", + "e1815e0fd2ef228576923331edf07564244ea0ef4ec8a9bce411089a77eb9e4a", + "72aac98e4ea4f230c7e17e26687594f09b9ba851430a2374bc86764cafe81cd5", + "b99fafcddb32ce7c664da0d03696cc7609f162f7ff5708fd8ef90ea029381012", + "2ad0dae9c73b6bab181f9ba583cd6135e36f1ede5c70256c76d0c325e23146a8", + "61578e1eb9bd641c12755d97eac9e03580103fee88abb89ab8d8fcb0d033403a", + "57029f8251c174f542a65a78b955563b100839e13e19ecadb16380c7f722ddfa", + "e2eb0590457d8d3b2485f18eb17eda42b66c5df55a8412d8e41043ac18ea2dcd", + "a6828f4846da4f8d28d0d70c4c21d0b942c048640e7a917aac873467477bf790", + "f0c69b7397779c42ec3f4ac766d40fcc1850715b45282ec65c0f3f7501210b2b", + "a46842d32afb26f4672710f6bf96bb3eb1e5502e44f9b6296afc1e0beeb3acd6", + "159856c0de30e3910b03fb44d19ad3226d02eb3b4d5e14e0cf0101f97a3a39e7", + "0e9f8d59f5c594ccb09d244bb31d44fadd6f868f7b8ee75d271cc872b9e3e39c", + "3dc05652d05f197571fb21788807caa8ba8f3bd139e2fe378f534cd6c1fa1b1c", + "9c4df7324b364e19828fd539ec135fa65641a0a14de901ff01ebdd8fef5e9f15", + "f83682909c66c58d4215068019992c1a026d717721dfbbf289e19cb25021f218", + "489e86d2b6142f6649d4663e41cf52db8a33eab12f6d1879ee04b18421b72a46", + "00162ba49e949c3eed146a8e5963138cda61cd5022600dc6d68b8b1db7a02416", + "7d60422b434cb295c77f760e49058c962bde3cbcba8d4e8b3bf309f1ef369006", + "6ed9bbced8a05aa65d8f89f44d49c16fb6e20d335f542fa7bdf0011534d16696", + "eda6374cc7e5962a9a970b9d212ea793326939ccb1301589511c599849f0d85d", + "d335c315e02c76d05ea9c54ae912748cebe93687f95211aab083b9ccc580afee", + "83e693b0a50ff26577ba5d3b6fd0d0ae9237d4a5eddf3cc51d4f9045e2a96a79", + "af5c8f04cdd95b7e307968f2dfe82201ec10c9325cd7c8d83a9d0b84b070d898", + "a01f8f06acfd16e25ef796cd8f11cd296db02e9ba711f3607f9fd19955b0c5dd", + "c706d7860a3432668bcab9f847788ddafdcb0d2ff31557d1d0b057e5e6be7864", + "9c3b035f031fc23b3167122b50e99773a6e0ce8c09a542f4243d5e2aabbd9119", + "305785162ec6e0738525913d8cef9d699afaefa1c2cef0ba1fc11bae4f554fab", + "06cf8e24e731c30ba10680d5d9bb7891d0d6e48d89f210cf3924def078823b5a", + "1eb3ab0a9a234aefea51ad0b8ae2f42ba1a3baa6252bdf08b1a34aeeec02b9f0", + "06f8164a25a933c76fc3dcceb1dd3cd84fa1e66764f221a05e4fa114af7f8ead", + "b49e582f787bc647241c3315bde80d0ded85811d7e6770a79ef4b7f243647826", + "9dedaf79fde1c10e03f44b0ddb51cd1bc58556f15dd6d91ee29408c12ee2d8aa", + "50434eb3e3aae009aeb7f92478f048d49dd74da4e099ea9f63549720139df64a", + "246c8773b410663c6f8027aae12f8cb8b212ccb2c2a200d670d2d69ddd3e78e0", + "68815f914c9b8adb7e5737a16babef1d013a677ba712fc96902fa23b04865e7b", + "37321e04c0d0271d7b1daef8047cc7dc55748b494677ffe9c19e96189353d52a", + "6ea3f4a89c1cc827cae360b4950685dfdcaa7a9486705590f05564f7231d595b", + "9344bc409727ba6b23d356ae2f7dc3f117225dd2d53c45e0845367a648378ce3", + "e1dc913bf608df1726e6920994e363798aae8fba10e9f271a9b713b8979d1834", + "3182acf08ba74d32d1ab9e7c1c0040aa18fa264d00cf5d89fd75c5f0eb50cacf", + "6f14765bc693017178ee7209b8d750cf91c7237864a0e165aa4a862d07e342db", + "1dd3ecd5e9c89f3cd4f23e71961978df77012224e05945ab4ff424676779759f", + "2012fd3b77a72509f38d8ac3412858f5d624be6ed4b2ea109b1500ded829ee1e", + "312dc602ead1d36b3847da1b1044e6c278d4800c33394fcb32f1bdaaf5133953", + "b4e46c41c493b16feb1b343baadfd84cbdf43832e33584f2933e0d673d5fca09", + "2bad92f2082da0d55c78b21f8b598249d78fc8e2852d06bcfb844a335103c540", + "6e6c09e690fd8baafea05f26ae3ea0d94835414e0b5f1edd32e4ca69562aa6c3", + "df677b292bc2e238fa2a7a3c8e66bda5805f05d82b46df79cf2d06931d6f763b", + "4da2f6ab93a4b6ebe6517a6bcae083ef1f4b6250addacdbc2b1679e2d5f1aff8", + "d1b329c59ba588effd8a7f618f9105ebdc3af199eb915558da9d7588459d290b", + "45b14485ccefbdb3aa14ebb954398759ccc3c6ca77e2ceb2dbffbbfbee2f946e", + "9fef4fa70b52ba95cfc3c9f527c78620ed39a8ee53ee4e694c64c070bac0771d", + "498010666f2be38ea8619213b1aa6620c84f3bb11416258b2fa77775a252da30", + "6914b091acd0352122eb350898c1dbea11f6248284da6e0a5c8e119cc241b036", + "acdae4cde1995e86fd1c9eda474659debd5fac11e66e851df4ea94543a131191", + "9b29979c3023ef59dc98d14cd8c19692bdc43cb39e34e148c5be92f2b0e1f6ca", + "b86e7ca73eb5c26592d38820f2709b7b5f515cd45c1692ec639c84ab00d7512b", + "f7d3a87c04ba4cae6eea3490a6ddee5ff590ab0666499743e4c736c82e0e116d", + "6429246dec081247bf5cab1eb8b28eff026bc51066b4f458f78c84e411124131", + "23013f27b84bb77a5a17c20a8a4e3f4a9f35725e7d3109bff77626b180d2a84a", + "d7dfd8e240aad69dc57e66b9df5e70f766fd80d19b5ff56e6b0929e2f8b4be0f", + "4e4681e4ab68d2b190fa416fb91329fa80eea243da03d997048cb646e02462d0", + "561109a16f1e6e4111e2bbed9076e99aab872b359b78812e8ff57807033f856e", + "c6e558213ce810e0ca56234a183e79fbd22b4cb8fac0265d69163c1e2277841d", + "740dc6a89ecbd4596b8c0fe59e751ba61cc8f782eaf50b5d4fa738bb104f1419", + "00dbcef563d23ad78177cedc64f4f3e5a0a5fa757bd81017bc537aa89c2f6ae9", + "0ef88528b3eee48d323a0abbd48e00a08cd7083c003622008d72fa9697b24d04", + "939c7b9d8e42b3717d20a8c5979aeae2f0af7e28bc9870732849eb54c8d4396b", + "3c48fe263b6d9e22dd747e0b54699544b3c556be305b1c411d8e41172cfdefff", + "260086e1b8ba006706ea5dc0e5caadda32a0479bf7f9836efd176d6548d09cce", + "edfee900b0767f665f5ebd8b40bf7e7d35959031ad647df8f93554c9bf152a42", + "75928df7c86a68923576a7cd6b38def4f39180b3567be4ad28fadeb8be0a4c6d", + "51d60d419a4d066ea9e6a79bb8e95283597f0bf34975b44f2d954891d1d6789d", + "d2c4496ccf48577b0d2cce11376b2a9e3d7b2dd62993fdf7f739843c25db76c8", + "5793f672c05810d786d4b3a8e46d059c75f6e5a464938e9bf4f7e93c57e3665b", + "adf2e799962416cf98c49959adf35f172ae03e352052a2702d5e2b4f0125a91f", + "a80bb7f440e907e27d8ed3effe5ad116f076712f81b575e2223f56fd646e34d1", + "4fce3135c8c4f1c8194b753e3fa16e48a8ef0a472262cc1d21eef141bec3472b", + "9567ecc9ae20a6544aadd44127b85cb02d7e917c426b659efe0c81be34d29258", + "d815d01b3c77f22d454335444692f26e086b0d2c764a5e47678f55c1a5e287a6", + "1c08cd6011d234cd52964b95ce5744225d43a55f77355c13ce2f3228a251a0b2", + "f3e1851812989f72bbc1441f720011492e5e978b941e5dc3642d6253320b49ec", + "5d3cea043b6131f59f98c878cec2d77439981bd673bb048e7a0f90215475b4dc", + "eb3ba6f1b30df8b1537ab3197de91583553bd1feb5ac5ef30efdd4f269bd20fc", + "6c46485554e49adcdc290ed5085859098b74863a114eca7052c3ab182ee587df", + "f9c63032d65bd98e5af902250105db034421f960df34567083a43ec823d0280d", + "8cb1cdee5515224ec3b70fa59b61fa7e84fdb9889eaaf70544e841aeb3bebff2", + "3da558bb1f1a694de16400cd255a0a09b12898a4827eabb3d0406f732a983528", + "52e0fb26be1193a3f1a04a9accece26881e93ac4bad4ff0a624e51b739f90847", + "7a3c75f7f55fd722a01ce54f8895b8a38b27bdab38e8382eab8defaa284830b8", + "3f64e3a6fe4a9a8f347b15b230bd546ead1b23b128aa38e7271c3a81a1206b5e", + "1fd5a7862b3d2b6d3c80294c5d3168149665023323e537e97bd21e0c0df6002d", + "b617d0fd6bf932503080eb542d8c6d06d5d990aa885ec6781cb2f7d33d5d36d8", + "eb1510d01e8539cae068b9f14d75b21f93132626b9592de2f3ea57c206a967fd", + "867f68920b4b18d31870e179649a73722051b8c4da2139c64c7e1b7c5843987b", + "3915d135c60df007c86282636663908d31eab986f8fa17a97ec1af5a0816d55f", + "e121a9c0aa0fa88d3ea6967d641745d9209d73309faf40747ae2990dddd740a2", + "4dacefd6fca83b1a8497931a471753af171f676b411846a3b514bbecf526174a", + "9d73b62347b0f6e4e05bec188686009427d75bb7f80c5aa0972e62122c2b015b", + "b334b9da9c0d8340c6154693fc3704aab07d815e519560ddb8d852323b825d89", + "3294017e9427509e190790e6bd1e7a0ee53b7aa13b183e81525e2fdb7b70f126", + "2f62eb67b2beeb72b10fc5d240f3f683f4b2c00e81facb76bb413b97b7500c23", + "9cdcf3c9f26d06d5d639e30fe87493b0bd76d5608e15d6e21398d1fa80bb0f71", + "aaad7b13f22a3eacdb3a65e95f4ebf77c18bab65860d47fc10d1b48873b9fd60", + "00e9c7ac58c303705b6dd5f85584d799ffb5e5c803b0bc4c77f4f7632ebd30a4", + "088d7923148a8d27659d527ab2fe330d81c1b508c9dae5467852bbc2a773ee61", + "f8056e4341cc05b2a65733beaa92080b9134cacd5846bc7c422407a0272f6551", + "4fff5c9b07b5846c9972060bda68b86cf731d4e505ad70cf7c682300de0954e3", + "af55bf02069ac7949263f5ba52df4c2ca7cc5ec70ef300e2b37e8671040c01e4", + "d9dd9e9ff1ed7a52e298611fe45326faee86e51db6e35a87fbe08ced995fcbbe", + "838e0ea082a1187a0515fd628bc3ffa9c4602ff80a73c43cac47e04335933b21", + "62dbae58b80eb817bb8200ac2c96883e7cc54407132a17814e01e596470aac5b", + "323300aa2734d595aba82c351bc208d5e911941e34ea24191775e8a85e4c5285", + "a60534ee3fdee27713c4e027d9ce022f55ecbffc2c5f5f8b5b326f480c0fac66", + "aac33119879de4bf5118793fbc2e250699d880dba0e7391403383f61b1a9e81a", + "4b73d5a36b32038fa31d473a7cd7af50659cbc8429f5e06b9521124b88e98f35", + "06de075ac6aa3722326d763f388846a9e1c90805445d1891ea1893c9e33014de", + "22f81e2e02bf858c0856073c3520a327f69ebf7794125aeb93627838bbaea833", + "70baef40f87ff6f508438bf9100cbd337834429c71e8c3135ef8c0375804b5c2", + "066da2a54650c744e4cd46ab888456722395c3fca099a3d730e563cf88e50d19", + "4dbb624f161ef3a4c85624cc6bcae9c80ad9bf99734abe86214f77d4afbb9464", + "96797c6a3d952a4dfb0e9ba2f8697cd9ea62722f296d02e36b7a3ce070deb342", + "19eee0fae2162a913fa8bd8dc0eccbec5441c1473368040851280dc5090ee828", + "acfde0f759f55630e11090fdb28cf5d01c5ef6050d61597a87f38fc532c86089", + "47c84bf3ccb2cec1fc96209eb1ad2ed008b1cda047fee87aa5428b26b0fd13cd", + "bec1fedacb1c84f60d2dbef6b8661c54579120761268a261d7f6bb058d679c31", + "5a8e307323d28faa017e3809b6ec5065b7ec4d910da88b99044a40bbfa39d0ac", + "7af0801a9852a3565a125444478dee9026065d754337f5f891903836383f34c6", + "3659dea4cd4157f1ead3cdad0f2af872d379775e90553febf7c42dad621b2b86", + "05482d081fc3b436138ba4d230679fe34bf9c3208134c5cab0a7c9962128eea6", + "8508fb326e1f8f40479c9371b72c9e835d1eeed753b486c56fc192b5b50282fa", + "b2b989d0f1ed40fe32dc91126ae15e6b9e26305a3180a2705099344506df25ea", + "dd46d268080d4ffa7d33510a7338197406afdb7adbc17d18a61ed17b46ad8556", + "0750e644b6ea955e8be4cf1234698012e680b76b7306890935c8e3d65786bddd", + "3004753c2a371837ff211af8df26830a2d930d4d2604b93ddc8fbc0019feccd9", + "8f3a7db8ff6e611b552fda768e96e5b3ac81c96867664330219fa2f40724b28c", + "874189986c30ca95e952f97e9b3bedcdeadff743c2b1eb36eba89c3d502ec051", + "66d8a0339e59c942dbd3e3e346fddd0a2d749ab11a87741bf764aae0c0e4576c", + "0de29ce5eb458a963a44d6fa48b43d2cca19a57f3201ecfecbe85ef4dba94b28", + "bbee1b1470ae52c350b8bf15ac84bb03d1a81ce9d5eb77e0ace4ada01f6caa14", + "b0d7ab6bcc0a2eff7f87514f92994b6689f010e993e434633cd222ce1652e07e", + "08ede6db36c4ba6f412ab6d00a436d94c829bdcb16ae3cff4ff8bf6c8f7875e8", + "ac4a9ac69fb2cd89bee04a3c049d41898f36ae04bea1d329ebcc9c18140bb4ff", + "e06a6e2ad8288ba63c158c24c41da0bd0d3b4e45f50f9e79424e0ddd2ee60ebc", + "33a1cadbc35a95a082af3ed264f3fdcd717d437278bcb9f2977768bafeb3dab1", + "7ca0101f81ee45db4608051bb8b0910b209feef5b1886ecaaf77e0a4a583114a", + "5ca9764dc2a27dc03c053e6269ddeee12f2d7460e9182121a8680a0299b53cc4", + "32edbbe7aa35684cf04c3867003a53c68c47765fbe97244e8111261907606799", + "cfc86e6a1dd6ac5431770c4cdc5d5a2fc6ae274be847c6a6c8abc01f2f0ea67f", + "543ae72368ed5911b90f5939b565a508ad316eea2d4cfa34fde4af8c9ede63a5", + "bb73053b66e643eac2dc36cabb384da84dbf008e91b114ed696acea43649f6a4", + "915cf23a528f1fd992aa3210c39a6d35a2cbf544e681da62ce2d9a74cdccd8ec", + "e5608f5f7ae24d3657ec296c33146f84d08d912f068449b6a32e01c14bffc2c4", + "203fc9949b147b6f01fddaef31b841569d5e5c674f22f53f2def667810ae47cb", + "46075f1255fb80a7ed2104e8b72a3c1eff5cb0c6cfc33fc7d10727e33c211551", + "e53b47dba5d2bf854ffbec567520ea2b2e2b3c5fc631e2451a5584491a5a7d14", + "26da8015775de3bbab4bbe81db93e814df8564e132a28915dfdb2348ec9365ac", + "66b455829f3074c37870193601d6bad894e393a5bb055a494b50ebc4d205cbc6", + "db14ba3d0c01d09f1e7998f8912efd3eb2b2d3d5552b7ea7781c6effc1101089", + "44dcd734bfc0d1c868e366775f52a2360a4c86287ae7354821fb16eef6e329b4", + "3fbb397e0effa2ad5dbdf6ad3035ad91758b5e8a292a656f0579e86edfd9e24a", + "e3e6c944793ec65db1f8c6dc65980489bbd23eb3ab45ebf528fa9a584a0a33b8", + "4687f239cffb847dafbc3a754fb279e940e519144f3e175cab5df4fdef5ca34b", + "c31c28379bda8a94e51a1c2fbd36cb0fad794e39fb78e723f81509276bfbd0b5", + "2c884db2a3b284f0f69ae374cf1869d596fb0241974d4aa8cba9b1bc59508ae1", + "6f43b182d98e138ab206cbc71c33906e76f67c6aaa4657716867f91598f17bed", + "56bb1d89c05268d2887488cd565fd257e0bc1157dda54e6a4062af3fc53e8923", + "763861f075143eec76eebb18e87be38d7a4458fad2d7c625316aeeb8a663e4ef", + "4b4790ede8173a7a653b8b61639f4086fe6eabe982b73d337ad0fce0d0d54a4f", + "a9ebb44c6303391a66b596f11cef7065c53616f4612e60fc34a539d84ea71d44", + "727ff6f3f354d6250bfe121965d4b0a48e00ccc8c8a5ce89d4884dc888b19401", + "6fd2f69444a71fd4e2e2fd233befd173b98ba5e34e0f2325dc25ab9330758796", + "f6010ae0031d586e81ff7322397bafde58685941a43c4d0a29d7d069750a41e0", + "9a89d8858f114b83cad0d7c907d3e8a2fbee35abe78c260d127337a7bb609e66", + "e4113e93a09e30eb4419f5235b4255b0c4b01d2243c191fff6c8c57672a863de", + "6db0770cfe26a5c7a1c8ecabac51c7609aeab4647ebb523ad41a4f26c90a7d00", + "b42d9268732cb3922fdca4f83bcaf90319b0016e6f80e18dbbe0e16ca953837d", + "61c8740f326fba12f8f51a9cd743f03f01393eaa95b4ca6e08089d531fe1b7b8", + "e35613bbfb7abcc24bfc967c08cfa3417767640c80f422540dcb7b1382d080f5", + "a7cea9373e1454c944f3b8216dc5bc94731ca9534a01538165e08699b187c68e", + "bb04f412124c81422e9992d1a66e3157a12765f466ac1b3790b42fcce9f0f547", + "f0b6f0d9703bf7885716e6602d03500597d6aac3bf6e625e6ddebc77ac0a1b54", + "b259fb34e0c795ce32020d6afbbbf37fe2b3be64f7c4bf42812c0aad4c4eb786", + "3dcb4ca8dc8ae62f06ddb517a457111c3956c962d5a5b8c314e0401afacf87cd", + "9e1a60482db1b99617604532f40451d02192e273d4a856bb45ebaf83aba1fc55", + "b008e1e5457dca9798f69c859ba4b3e3996870a5e9d6f6a8a6216327e672625e", + "2e48c3ddd5c1e6a72d8a50a7f30e44d2fe81e0b7facd751fb90808803dbbaa99", + "2bc0d53142968c6992fc0c0e2c76da016245213252448b4efa1e9bef47217eec", + "cf7c30ceed022ef3e92e73f7c17f866a6230a92bee53d732dfbd521428a0a9f0", + "fdb0ffb8e4e629085c870e9dbec3b8fcd769d5b12466366e488b2ddbd55f6478", + "ceaf45080007a75e258696a8b0169a3a7ce9ad7ceea386b47ad2485eb2ff45d8", + "6e892b9996690095e32588fc9e199b3b18e7dca1edb7dcb784cf677d1707c6aa", + "1f34aded433b84d6d9c29a59639abdfbf14374f59974b24195be1003845d736e", + "a6e542cfdcf34d089e02d7d9bed207c0ed7b3823d837b3cce3292e9be26fc7af", + "666f996832b0c5657521c4fb17c974196852a46373f69b205e02876d2a7f4b3c", + "6b7470907b5547d4fe740535d2930e816ae396d86ea232bac70063ceb516d79e", + "925d48117e08f6f34627cbb25036a66ac83c9cfcac629cb24edf5b003fca4c49", + "71062a303fd5bc9a9dfd3e6da076250a24ebbbf9c51d7b186e6f6f9ecc5e749d", + "56aaf846d9c83ccc22f26bc05d40b971e02b67ebd3cb40864bcfb2d32b0bf41a", + "b660208941a4c092c07173f7790784e88f8ef130a4ab41a9ebcab762af4a0ea9", + "31f9f40db6f3832632ffc466b6f434062ff923b986ebbeee42f53426ae87a873", + "c391a67e84581e90cb4a43b619cc7850ccc759e864d78ed69c2bebd98dc9eca2", + "f5cfe3625b4ab9bf36f23bab346f98347466e48760ff7a6f0ee2eec0ccbffb23", + "928e113c1e118b6e892acc5425583c76d901af3bdc0ee3300959b9320a65ed93", + "d18d08e6dc3e5862f6aaa6c76f859ac00da82d05609b44f40c2556ff600b9186", + "98c1d5e453e293afbba640bb7e504cbcb140b7a8d49925f831b0b8df75d6a4bf", + "7147cbac667843625d0fba7551aa76eb6dab3334ddc684bc2de0e52ce3ab760e", + "0866575c45d93a913ebf327db9f75254b291646f52c13dbb3c1ed2a2e357ebdc", + "49cf006d5c99cbeb602ec9dc173303ec9926733d7b2d58e8c72c66b825772978", + "4e080638d950c5f612cfcc83503c436bffe56612e3e4bde88d87fc1753237c29", + "7b2cbe55e35e876f4236f4eccf3c30e3900e38d333c11cfc1f6c29dc959b4578", + "be3a7bd0ec54801880250af66f9eda2d539acfc19ddfd5940ed602b617e5503a", + "85a95b82fd6ae653673da6d36aa39a96339aba15f2f403925505d6904b696277", + "cd1f8a38950545062a80966c84732d4293f5e7b04b4ea257a74c2fd64a86d533", + "7b9eb84d78cf0cd4dd574bc3b7bc79eed63998b724f32d90c72ca92eb6a43e2c", + "7b5f8aaacb463e91b335cc6d22ef06499e5e33bbc1a23d3ead7cbb78e41b8adb", + "a02edd640655c6ec916eb3a6b423fc29c13e7a4ec5904c661381b59aa1c78089", + "92320d47ced011a0af9d12f8001e7cf585380438b9aa1a8baacaaffcc36dcd02", + "1cce9975daf6d0039bb6c9d3898eb4c12452d18956cb9f28af592945de094a56", + "5f0ed3cfd78bc493e2619eff1d807c0b3693c513117c2ac4040ff347a3ce99d5", + "dffe4d0e7656c17b55fcdf565de3cafe1514680029d7ffb9237cd994403b77e0", + "e6265d372d455500b92f7982a5833aea6d1899b9896b9aeb63c19a1ba8fd4960", + "34f87165937447c544cd557a54d05280fdafc3cb3dc7f8cdaa606a78a256e3a9", + "78f81cefaeb402c5d02cf5d897a83122973ac2d8a1e8280f157ac59b4284be5b", + "b30d93c81f4cba02fad61e61fabd743ba86013774503c4e4d59768bc9524dd51", + "ff89d819ca5c60a9cfa5d45e3b79c155db7e3199496de36862b51dfc50507ebc", + "237b8eafcbb45e08ec8d4673dbe568215ff4021739c8031fb378c041bd11f0e9", + "971722cfdac2836bcf693fa73c03cbfd5b1ffba50756c943766fced21dda29db", + "ee25f31d06bd44cd174ab7ddbb52d12ac4fbd74dcbebcf810b82b130bc67ac63", + "7f9b39655d856a5444e23da087ce60b24a67777f99d6b07a05b0435c0336952c", + "4255b28c2c8435ac486ffe9a79daeb8f2dc40ee6b83a6c9fe42d2f3d4909e457", + "b592eb6ba2ce0f7c6ddc8ce6c8c6020883b3291971f8504fd3c34b7c3e7e1c31", + "d2e12f12d456397c845b588d605e9f144a7a7ba2cd445eab5adca8f8d9cc0483", + "aca0991996713f03e4ce6a06a198b3b92d267ce0aee2b6e4ab54abe9ad0dcb96", + "1297bdfe9d37f2838921556cb726bcd7934c18b3ac2c2c75b903bef129c22ef8", + "fa670be9e5623e394726dbcce5355daafaa75232b55fd5b4b38062005dff31fc", + "643e0681f3d327a1b70cd6a182cffdffb62e1f24c0cd33795687fa302028a469", + "a6dbb725523894df87b7017f579e19ab5eee299f4b0219a2f231495f0d8e1668", + "d39690ed704eb61de1c307ef6fd04520d65652975d5191f1ea0f03c6f1878cbe", + "861ae253383c26e28dbcc175f7b56e15ddaa9b6d19a5789aaf614f0ab644811b", + "812e05aa44360d189b91d05fefff92cf2dc6244b5892368d225648d0d3069336", + "ec3598e77ddc47e941ba8c5a1955767f4650fed5740a1548a9f3f05f8a5c08dd", + "010b6a9b53c29ff335a8fb79997c5580a30824291125a52b12af29df8d9dca33", + "7fa482e9acc1661a5e479a37925837c77b1adae1656330e84c72304eacfcf2e9", + "b653ce0c80cdfe7c0d9b1c451dd1f9c70dbf8709480e16a64652ef33ce245f75", + "9423ff12cbca9acdd2b92cbb1be2191d58a828746b9855a62a279eeef7e7e013", + "17024ecea5a4543d3a842239d4dbdca588c963d0d9ee2fcba2d6ef8e1961c642", + "f83de5e58679a9babed4c0e6f57c3689fc6445a72f39bc9d2e8272d7e615679a", + "2acb5cd30d165e9bb11b8618d42bd53d52bd33c65551b3a3010571af15e41c01", + "00821369258ace38acf540c35b8c318f43d4c22f0f121cf00c2a2818ca5e4d58", + "b6938375aa7f577ad107ecc3781f578c8cefcf0358017d3429ef0078bd5b257c", + "cd57589ad5ac01d653957a42dcea8fccb5eaae55f1ed1ecd8482d5580966b873", + "647eca2b733716b659378aafe9a8169df84cb90321aedc6f983ddc5916186d7f", + "2998ba3158dbe60aff2b16d9c1d24e4ef69db4ceac594e566d40e8041f79d24a", + "da8d24703bdde2ffe7b1de38cfba389067b6e57d810e9c6140cf35d0a259ba2a", + "cc815136f95a9b347915512202784f51233a5e096746b013dcbc8b41164e84b7", + "12b6a194bd2d225ca452ba81fce874a79cc6ae11bfca4c73f8919abfc7fd8880", + "952c1fda13e6d01a0f72514fa7db899b8c11b50a401bb25bc6c209df0d95875c", + "50592d9edc8f4d17de0fd287488ccd7eb4eba43606cff411c4d9ca904b237aee", + "86a730b047add0b17e2cd61ec04bbcb979fbfc6b74557c704fecdb7caed8a09f", + "9442b6482e88b5b7a5ffa5941cd4d3fb4d091f5b288daa6979606c8df8c261c9", + "1602d2ca8568854d37f40f4021c07a7ab41157b26da970b591f08b50afefe629", + "a629f05567d107e8473ca3fd98a950d50a76dcfce8d2da6b54d3546758c76020", + "d342fd86852d1251485788a4c660abcb97fd633a626bc2edf30d11dae217c7a0", + "ccd23db89308864a51a4670a396483ae3bf6268b9c6093102ea64288779926aa", + "6d3b4b3295be5dc3336b61bb76e6747aaa342dda8be9d46ef2b56527bebbf08a", + "d05fc7e6bd4b946fe6ef3b0540e8de604af73215ea7c06d8af27fe57fec02fb4", + "1501ea28f6c165f620e3126cd15b077fc029338313e843726f02ae9e303ae4c4", + "bd87e3adc7b4f0910a2e1cd9943264a02aa83f4e7cf2e18df9fd8f8a81a975d6", + "e02ee46e6f9bf227b79f490821add7c8da82673ead28b185a25e4719702af2b1", + "d462388680d59bff84b0db2dc3bded66a71bcfc598cbc82d1a323089d63e56c3", + "b5065b35ff0268c7f95ec7b5ddd5d07a053bd8114249b5d1d20c7ed7e1804d3f", + "9ed266b5a5a9553a8db35e2d5100e132a59e9cbe0ec515a790e947d1e58ebfb4", + "4929ed38ed61217868d40d6479b5f9017228fcef89c707cc16a6b8018568c34f", + "93638073e650346208523ff4deaba51fae621bf0683a30e1ac7f2e5445a2fbb1", + "1758530d111589b21a8175a3296008472c97b07241f7f0043cc6de6d1758cced", + "db3857da9fe8eeeec6352cf52de39ecad752438fc0de9507eb560594777a190f", + "3a183c447bfa1f20b332b705344095684b548240737d639fe1fea4715458a76d", + "45df318ccb2ab8b5a7b099d9e9c278bf8312c502c5f9ef4cfb872953ab796d54", + "83ae57ebd775193bf7c002f0ce8f70af1a85d3d5022ecef8ec7e0bae0eea123c", + "2b00b819b1b1c1a590662cc54aa13fdc6983da3b4935587c118ca48845a3b5b6", + "9a0b5d191aede4147af667dd40c80826ae5fc54a7c48cdc44c31747ca3296933", + "2b2825271461e8798d4cb34bfc1c1d65ca814fa1bde2760e0e3eda20ab95b73b", + "7422bdbff0d22966bc53d1e5ff4656fda5d3a3ecfb39bf184c1ffb57d20d0eb6", + "989ce45f84524611e8c643ae061ca7f730f136f8cbd23a953d479d7794311217", + "15d1abd43618854d90adee34a2a32897771eb05be2b8603804d336cb0dd1920f", + "a1f0ad6e92094428c69d2accfab1db663d61f1c33a7835ce55c4b1802d684199", + "c13b78297ae2bd046bce2b2884723a219be101d91016be20ef55a2231304d8da", + "61184d04f45bb122a75bc2c8ef814b1fb44f89493debd6d9085132d944776b8d", + "7999ac8c01d39ba8ac794947f62a9e050941f562894bb6b14ac79a0ec0341e8e", + "ec457e4b14ba2bf19655e008675d275269d7354dcbdf4c5c200a7fa0d10d36ed", + "da472e5886923f9f553ad274489477211cf7917ba8d1555ff992a1447d5e2171", + "c435daced3159c8a3890d63b4a81bddb1346695d6e505f891c891a82b1cb58b8", + "0482dc5957ed487930c7d4ab2720130b4aa15d701d165f1222810e5b76a6b5aa", + "ba73b24a4678505711f655fa94a1dd6082d703206c0674125087640f4d9f529a", + "f43bf9a4719d2bc39c125b379ac80a419e50cd1f380d1d331973f3d0f2d5ac16", + "a6647a45d342bdefd877b441336d1a6d0411c441540c7b5d69159a3232a802bb", + "1493964d28a3ef0fe42db523ee9892fd6dacc1b926c8315804bb47a09a7306e2", + "ca7f0f1a47319616ed4978165a28c3829cb17d70b510c17e1f41443dc16680ca", + "5bd625e77a57f9c65fea28e5247ffea15680a3295c2732e2fb36e19d1be844e4", + "528e3e113396106e9b2a3fe46a9103ffd99c6d0dc2d178ae7f778e15dd293f6a", + "bdc284a42fb39e89b0c4cfce5a0ea2d3872ae65e04f8ad7585c088aa6aa750c5", + "b900ba3fae9ca7059c2892a2f4e2a0e909c25e3b5938ca2497dac9e314eb0ab3", + "c48f02ad2bec6c3084d77082040ca4edbbd360414b0e9c1cdadb8a4d01f91b5d", + "7a65ba1c6d3b041f589e854572b1c3dbc89b9e1b569359f484c5fcf6b00bd663", + "0bff43fbb4c53a446f25d197283094fecdd9993ed7ab4c8512d28699fa38b8a2", + "8cf98efb7fcad27025d99c0ed6d1b947d0cf5c994ebfae98dbeb3a0cf4626f2a", + "8237b0de08067413a98ba1f254bae056d5125fd3978eca25952440d205aec2ed", + "16ae6a142c84f780f2d064d82f0186e8d410a95a8681a0a94610dafb1c561e1e", + "a5bcb8059ac0eb5cd9f47bc351a071cf99f1366ca1c485b7517e95c9556d728d", + "06a6dbe913f6aed53d130e58c59b3fa0cb1718b8aa9451fa8d32edc4c699a7bd", + "cbfcbc64cdba6b9f404ac5adaf021534a3ab91e033cbfe8639f30256fe6bea1f", + "b902d8ea9c7c20315f9db7e698a816f40aa459f2755f4d3af7e8ea7de4d0557d", + "d30928e494848ecc15e3c998c43e564b8d9ea879ee8a50d3e41e55dad824d6a5", + "dcc5fe2fd47c6f76a58a3ceaf96a349f3ee43db33d1c48aa4703e85255f795c4", + "accf76abfff8f217efbe47759fe4351b6a62cd2e2dc098f13d402ca7b67b183c", + "2f0228f03efdafa1c00a1251865532577da6f7c266cad9f0ef5a45d0a1929673", + "c3904e530fc34637a79e2d102151041e9f091f6caa84f504653818cbc25ba040", + "95bb7476bbb5ecdfe68181d57227215f034b2f498ebd50a6b99bb2fcc8d2295b", + "6c8595db98d2af62bdedf5a6abbb8d620b85588cf65a5478b1b5eb15577e99f1", + "c36d237a03680ef6bf986914a9056c1cd0b92aec05916d36ae706cf3f36693d0", + "c73de97cc2b8c5978ca5c9b7ee66e653ed26c19dd15710485b1054034bac5699", + "e8d810a563f12b4f071eb9b2bba562931be60d1986ce68a729216ab6b74178bb", + "1b5278f5a2acf030acb17f8ed16c4cf826dca8f7d8c686dd38bddf1bb3cafd60", + "d24fdabb2b04496361dcdf51102fe402e4213ea5e36e8e3b592471b88c2c32f3", + "97e8f80e5808f243df21b07463615fa371e68247e1cb473065e62e3c068c5212", + "34e84541020c912397baef48920f1ae0aae22f24ed317e6693573013ac19d25e", + "d2e41ffb405f69da54a8a9c6b1fb460e300d4042a72ee7fe61ed576da3466a4c", + "4391aeb09cfbf23b49460e9832c6057bf3c92721f2fc8b97fdf5da4407ebe693", + "58a0fb1b13d6e4894e24ad3d4d6576532ef8187a0f8d4d2d018a70ca95e2384a", + "9790d23f4a06fdf6ea3ba361303d7d6b715e9942de398f8e977365f387705c2a", + "b41657652bd6e9b81e3d136e4e3c89fa774cbe49837cb158901eab99e347b482", + "99712a0d86c6d8fb44f5b8cbe8d1a7d79660801f904b00cc34309956b1b8458c", + "03f1a1f10fe04856e48df4148e1b4dc3750d1378633cb83743a3b42ff892827e", + "10d70c22d69acceabfe40633de59d1cc00ee13e1c22582fd6d9d1db53dd3bf78", + "d95907c4cbd3f6804000e74a3c8b4cd4b21eb50a786ff7859d72252c700eb247", + "7077d0a4054c682e6c9911408dc1cae9e0b822a03eab201e3a46d925f3f3d594", + "4b4aada1ff18a664b0f49ddb7fd8a5b8f4adfab2907f7d61a7465be32a5e54c3", + "e375b6b14f3533ef717546eb9f9da1f10af2912ee9f469b187771b3fbe3ec81d", + "c2a8f246993e62d036c0ada6e7cc43240ae5fb2d111025caf59ab56359572bb5", + "5bda8715b848d80f46cbe4d4281247740f47847baaeada5901c372fca372f253", + "69150e416f10cd6c6f529e7afaa4158d74d0339ae59695f70141452489588520", + "62e69cba01ea7ed2f71d4f7229842f4152a615e4e6d1e0ec9f4489a0286fc959", + "8135c52d6fab239272881a757b8583aa04fa1043a96e7a84a08e86f72306ad89", + "df6aee4219dce6f1141839a79a43b40e160528b73b4c530aaeeaf04d507cc5ad", + "6c005b42733524040d6ff1ed8edf287e01c59d4b8c22155f7517eb60bbd0cf90", + "a372d2f884874be7213a268b65db2f18b473f1840e745bbe32bbb954dca1c4f9", + "75c06361f2b4d2ca7827591eb7e1608919d3cd7b52fe3054d072c60ed80a35e8", + "25012aeb6197c4877070b274be59200d768263b34e8a1f685982ad2a2988c4fa", + "8048c1c1a4f2abd395fc36c44a828e306829b80c79e427187c0820ae48f1f906", + "c675a9c35e57a8041cf6ee745f52f37a9553a832c99917007ddf95229ed7db98", + "755035766a5aa8f4b8a143c3db1350e634c1ac34b022d572228712f7ddf59961", + "3a9d981c542bf5d1dc5976c3b11588cb4453de25fbd12029532240a9911c66da", + "084cd917c80b09afa96d3fa53dd89d70e0169354d1be9d99689c737dd57b77d1", + "3159e3d922b80a4ad1c071ac1e1db52fe436a5706651b4b85c1f4138f5c2b9ce", + "9ab1e375afbf7535f1ec0b52017a2b3c41b2dda978d639c654531d9560e34766", + "4fc7a595f0107f4d78d93e2bce0701c3e63a32403b650e0ab79dee865ebda95b", + "e37bd5acbd0549ca15c05b8ea5d3f3dcb7b1732dc96121b5617b6d811b9548a8", + "cf114025629d19ae6442ea6fdbb1a7bbacf2cc1aa3e93c0e43993c3c3cb81a06", + "ebbd63a0fe03c48a9f4c35707f341ee944066e1dd38021dfe2e49e4eb1e1cbad", + "c9f70d69503a9c1f9804e73d6d391d1aa5388ce4608435a6cbd0b047cbeb0a52", + "560d146c3e69683e15aa81de396a33a215f9bc19d6f765a7bf24e7261f91dd23", + "39c3082013dbed001d1a9e8cc43fb2eca964e92798eb600cda4d025f7070bed0", + "002f3b7c4aee398b57c524d349f97cc75cbea2684757ae11b8c5ee830dc0e14a", + "bcfa9ad8147616ea419b8abcfb9d7fce5bda27969bf837177406d550b24a1abf", + "931a91f282fed8dcae42e19422119c99dec1f34d6c6405cd31c49cc24df12468", + "8d527696ec5159cadf3bc30a76038391029b283e3fd1296308f9c0c640bafa3b", + "cbdb1ec707d5fc8ba2249c19930c5ec5134c8f342bfd677656b36faf1337e806", + "a3f36b1eafd8084d24b1fb56d8a54bd28c6d5f366abe3b2ce6fee66010101ea5", + "3b07be3b0074ca7a7254e83d05d7b1f523e93151bd8ddbc5f2ddac4d0ecec529", + "82b898f1f4974764e22651c2a1319697f94ebc3353c5cbd5c2c8cfa670dfb6a8", + "47ebc96350bf7a431f3fd589e46dbc068a66a1c7049be7a6d1ba80c287dbf143", + "7d6aed761887ad6dc4321ce35a9b6af9c2f06c394c4272ce694dbba4dd91be4a", + "07a316dd5bddb77ef66a259e974b173402aa3fa7f4fc4368ac3924f9f4b5af76", + "09b84b6bb21df3e936e7650054eed14ea41e1216f47fe58f75a9e5eef95c585d", + "a8365eb7122060a0257ae601e559a6228254d368fc0b0bcf72a70499ecdc96fb", + "3d4f1dc78eeb8f2fa985696e7df984c8a4f77dc567c66676b903778e0f60503d", + "f5e1e8bfafddba24707e6e363f8f8f1ccd18bbfbda2e06285e1bd31fa219be7c", + "f1091d96b18e2783efa174d0d6bc0ed9e10af5d58779bd2e635b6fff23091ffc", + "b3aa44b81de24219933c63111bd024e9bbfb73c910e1233fab476fdd9bea8e0a", + "f6848e25467dca2720265131e43fc90e0e4a9cd647954499043ea133af27decd", + "cd3c984711a188288b7351030d18813f0dadd657cb2c26524ef2407b057afd70", + "b52a2334f7ea44fdefa04abf2289a325d4f67effc8eb8503c48296da23050f39", + "6bc9ef1c3967828fc51dccdde293f77e46e893f8151438f2cea67db51d3a9d0c", + "df783833bf6b31ea1d49ce0b76216118f2b8adaeda81a227c8b36edd1b292a95", + "0f50bac15f728ae3d57bf5fcf66c3d7339ffcdbdf976af3491e6da8e949beff0", + "0f4c0408a4d9e2147d51a53bf11374ea400d326ae748c1ecc1fc6e408d6ef139", + "52db906fe1a18efa2375199ccb93320051d806734f7dd5e64791f2525d7cb3e0", + "ca8a9f16672764855018ec0cb110e53fb8496f21dbb46f6e58ed82a8f5311362", + "787dbb4046c2671466d722fd4bc88bd0e13606df32d52ee2c7d39d144214776e", + "a135a92275dba1a875c7cd3b20fe891b8437aed7e8943a1a304834d6a925a0ab", + "c8c404c86b294a4d3ba6810d9974e5017f2bb78c5f3629487f91f9c2f7f4ca6d", + "7484a61be38ac945d7ed44e00e92958d50fc71b68bc9576e647e0c4dcc783289", + "4fa13165a8a4ff33148bef30544b85cd2620255424570fb6e1b7de2b22dd2e26", + "55a4d3a594b260e615dd6d0833f2a40398d45f95de592e36c82273990e9eb667", + "3e763fd113ec9556c0f6f88ed7f5a0e3bac8c276adc5a5c2a87d444d397c03bd", + "14e631fa0511757bf429e821ff45e99168671bccfeb75cdfa9a7fa094f6b42fc", + "bd5b45b3f6af949bad2ae367ceee99ebb8e4a336fc6ded47e4fbb487fc60aa59", + "53691c111abb58ed27d15bb37fe0980d43fc7c3bb7affee8ddc91b6bfab973f2", + "aa1f9d7dd42eb5abda099d7309c0f9ac49d9f26e24607cac39aca2c4ea82be56", + "4da6ffbebee278fb496ef23f64b5f6446639700cf1d7cac8795f40706c6f3933", + "e04b8abd408ef5552ffc09b3cdf63bc93f5227684270776848d9dbb0a25dbe00", + "b831adf8f5309c75a39eeead9d957b205f517f90dfe3ccd8fd48fcbf256aedc6", + "cb43dc64da7b44ca72cee82c9686d489cd8010b0951e5d218c2b0d75b335a2fa", + "460faebdb7b5cba7fce52def7312b6086c1700a97f234d471a0d2ef6416a46ea", + "372b4db303cfd6aef22819d3079156a945d352a430267b86e1bc4037310175fa", + "5712356ac5c15a018d35a34364a313007491de68499f2136fc1c5960600a08ac", + "1b5fc2444dd6fb13bc1ab556e9efbb7af8d779c0eff33bb0c442cc8ef9304216", + "68a0d4b44d74f6281c681b4d4449326c45218f9041a039b5ac213fa3ebcec8ec", + "36bac390aeb2d3374709501ba28fc529ddc1f3dcbf3a015a69e1cef2cdb69d27", + "a0ade37e695e451e13a74ac7b71ab61f23d2e94a494097c2ef89e454ac889c92", + "b7c4952cb5644e2b1f4a292591c09343766286ee61a0e6492362c9c4bec38c82", + "47326094fd8330cc41a9306ac749a16800c3553284f2bc4014fe34dfc492ec5e", + "53d12200174681aa130d45009b330d6e1d3db0b4c984ea636c82fbe52cdb9913", + "7d175bb98dcb4ff39c92552b50b6e1a424f7f7c3883de2f478fd8a81203770b9", + "ebf1cafa32b4b02d69e92052116e0a9b2000f134c65cf22378bf6e5b9bd4bc7c", + "cec6bf10677fb5f14703428fbecdda72872ce50281d105b3492e86178ea99454", + "e233b2fc0844d80a6091cd7d268f99054232498c1ebbfc2e48ef6a07bfdb64b7", + "7011ff9333f96fc0e91e225d7335da6f49352fca06a0d541adcc86d2cbac1905", + "f80dab0f20b98e0832faaa510f2284a3e8486c74751a6e365588537d85c49951", + "e087cb183f4f7db7d23a959a5e6c07e4af107f53153a710dc56ea6f07a9ec9a6", + "c08415bff7d216da72754a85b280958d00ccb8c77390afd4d6ada3266ca861f5", + "b737baee84aaad2d7b5ae831fa385f55645b87c86fb6b1c855b57ac2abb57cd7", + "140bd85fb6675f759114670ab7ef209a96dd8e33deab90558dd66514a67ce8ea", + "71f36c67fc7d4e0447923e925fb33cf0e94345212393519697773ce5b9b60783", + "e4f496b0ff450c02df989d917e42452961ddf7a3beec6e08c8175d3c7f800a73", + "c34b128c25c4fc9a014c5f97bb865ceb39b3afba0d7dbbcea43249fd869bd202", + "da1b91e04de8789998b3e4c4c1a24a9479e084e20ff3d53eeead2d84d190e344", + "bc9a3edf7639831a60100f3e8bf92ff701102d7a2f26f5db9146d961ff1c572b", + "4d35613dc046819ef9d6e7b795ccf6677468a397e9d72c3699258868849b298f", + "f8c548f37df8270d6aeafa7837c71c8b1100eafc369adee67950858dc46eb140", + "8009b05c2888cde93909d361ab83f803fbe917bcf9cc5752a0aaceea03c66f71", + "e17efbddcd33c1fd285fdbd686b95e5b8033a107f40ba76927520fd5b5006174", + "bad2eeeedeab90fdff504e5c9994cf23d41575e331df5a3a607703b18ec4863e", + "5bf299a1f09e49f8ba67f4ecad39842f7c71099b6062b491d47df8454d06eeb7", + "d03ba799d4913d7007ce922ffe1914a59735d941e45f4a6420a41a29d91ea331", + "6c64e4920cc274d21bc1814dedb71bf1334b20fc5b48f72a7f7b8179184e9524", + "84cf3be5ae26feb0b201b664c1042087c15104b17ba3c3c309fb1f8e40605044", + "a47b87a9276a4f8f9ae11cb8a6cd0a641828057c5a4dea003cc0094af1268519", + "8a8406c58fd3b95b10762d6fc58510976fa718bd05f6d1c7a004ca5ccd371e1b", + "f69d38e5d6e3781bb5fb9a08132ebce9d21f57057977313525b736f557f45d27", + "f73ba64eeaa7b0c2714191e7ae503e09700f664292334fddbb2fcf591f5dda30", + "323b92340879c3cc3d0cf4c2e007c24036de150b6b6a797a26f915e12a187676", + "1ad588f5feee63a6ea75824da65a547e88d8a24feb2e374f5c93e2b4d24c50c2", + "33948272ea977373a191d13a7c48b79b1c35a078b0efead88511432a09278f3d", + "1ae4dc481c12ead8e5b0361046eb3f8a9b96f250df4f4c478d3c356b49053d98", + "cec0d004e66fc45f4d37791e24afe998118865e9cc086139a00497156a81bc2f", + "2a8cef4e60b799eb7899999115e3a307686e6fe48c4ba39f56b0da01f4ab9539", + "f9cae4603cd29e13be78b1d15f78313445f03b0964ba6629620b15b8c96c0373", + "ea2f024a51d8933e545457c9f28e7c31bb9ea9453e8a015701091e7b87ddd40c", + "5e0c98264830ab6421047902b5ceea9e88a737700de39e30fa32c34e7aaa0c82", + "2b191e069fae2f8b5ca970f00f20d34654d9d465d2d5b262c793baa641906c4d", + "cc3c7d1d5cdef9e68cb85588ed724ab5fc2226f35a5cc5dd5b0cc730d4151f6e", + "ec3b057d645025845c62a1d3d70366333741bd5417f072dfa5696bedd5c8528e", + "14f9d6d2d6a98019cc1c3402f0330a47976e512902d8c350029b52c6b8972d9c", + "6ed60f73644bb2d1f71b04697d324ff366e76289a4b8f2c0414ac3ed74b14210", + "ab9b1119784334919897db50c94e1cbdf5a844902da4661df9d8feb65a8431c6", + "11887b66c827589195b17c0b717c691089f5b6bfb6f97c09b8cc71e054bb742c", + "98cc4e4d8159f5c79b514e6e712e88b81270d6eeef9f5a2c92bf7f8bff95a8d7", + "5e5024b5aad9a133fa0ed11c6fcecd45d7b0007bec29005110ddff11acc9effa", + "d6955dca5e65bc49a62030b50d1dabb3aea223f644b6e529de7c76b6dde53288", + "1ce1e7d69a5e8e6cc361cd8c5c11424ee1ccc0c5f364f6fda39c5f07b0cf36ed", + "d3b9a68153f427564407d55fc3840a263c1617434bcd5bf61454c37d4ab7b545", + "183aef0d814c38c257b1de28c3bff93f7b006bb120c6a89aeb59b2d4061cdff6", + "71ffc609b110534253be7eec76f92df9d1e9ac69ce7d07f98b312e7a9b70d1e0", + "605db5449ee7770694aad2c426fd2381fc66faf4686c0e990e24dd2f1b8e7ad4", + "e4425f305f9d6b1c96e91c9e265d6b3bd287324d0c8c5a48d12fadb5862cb145", + "c998bdb4b1ee8017cf2d69ae995806be9d3a60daaa184a1d3c7780577a3309d2", + "635b6d455ed09180604403d965622cbc9c47e720160b98784ab9b217a5fc6aef", + "9b9d67892731ad1c075889c3237f45a5a3305820c3de3f57b434b18974696d0a", + "6793d4feb816c9f5c8a8dd604e87243445e57983af7dfa7f54393b7612fafd30", + "c14593eb65b6c61eab181cf8a46a1ff4c52442126ea6a37eb870f940b77d14b6", + "69904f0513423c9a03482645b4af4fc683008f4c1224a6504a2fc1e37543aac8", + "c555fdcdd776940580faea8b64aeb7b8df19c8850e68909cf8853fc33602f899", + "cfbfa61cfc3556fc4b171a7e5e2a4029952937b4705b99a19a78e0c0ef293e1f", + "28e2afd985c2ad24debd6c65ba514231689b6ab9a44e2d8d70ab7bf68c177e7b", + "9b36e8d63659cfa15a209c3cff000ddb7bb855875553cdb80b14c7a84b2ed9ae", + "d9ac1b8254461997aab756bf171c4f7e41dd75847cc233b677a3fd8d0ca00295", + "e4ae312493f0d8345be42668647aa54e83dd320e6084105919121ca7e59053fd", + "717ed6af50d4b6da729e7b4129c38409da7f525f2a0ddec050643bce2263de6f", + "497036d61d8928b7117642a5847c98f3740db1e76780cce7596653ccbe39b52e", + "04eb76e068f9f1c330179cb58a3b322459823ed1481ec4b76711e6431aa8d40c", + "f320488a2752f4911da641eeee0064da1e87886fef5a2cdc0e8722815c300acd", + "ab72a67ba77dae89b3b5840dce5d93e3d38528586cd33e0836c912e2676a3b67", + "5946c839e512f33289845533e546dd09f321c09c907148cd35c9803f6f9286b4", + "e8d8134cd794364e69e3470e58c5075c72d52befccf7d4a735dfac7a15f1a930", + "21d6a56b2ff6c599a68f87793a530f78966c5b1b1b384377b0f2d1e4455af1a5", + "28ca0b5b0c936c1b05850e30f8de470acc2136b15fabbe6961ff7ee34051be3e", + "fa7a36f844c00378903e0f9bc5b1a77ef3b6241c868772dffa6a8a1a25e86f47", + "a00523f71cb4af9b40b0f9262762182ab876449ef9a42cf7fa0c4d1f2d59e452", + "76df6cf6827ef3e4ce089c86a324be3156f87e0a2d5a13600b88917de9f498bf", + "e86bd8509ad97745316f74db57fe9a78edae2a5b13f8a4643158c1f7e29bf400", + "ede8106745da6735fb3024c95bab56dff664e14120677775fd5621c517b47bf1", + "f4801fa73c6de9e5f03c981f70824bce510a5bb3ced622f22c11b55479350350", + "210cc001daea91c7753f4bb52ccd790774b0b424396549a74952d40df21d964c", + "6b7fadb461cd2b514b766dc2f6639111f22bcb528beb5889eb85a868470257cc", + "cfb6e9bf4f52ca2d56107663efa486f0087ffb590f42d6c8567a042a6ac4513b", + "f2571c9d8f33a09796f5a29134d3aacb6728f6d5dd425c450c0560e94df16945", + "8ae2d9715a468160ff2ba57a7b7e170603ce0f0f1fa8bf9d848e23ef6143cb8a", + "0e92a47bf931279dd9460ba9ac9b74d07b14c0f39d9a6805e1c37aa72b077068", + "123b3f6f2dafa1616d788cb2a62378b9df4e9e0889bbf29d8ac5898b26464d79", + "32d59d1abeff80266624c2cf0dd3a467392bce70c80f4c675530fbdbfb5c71de", + "5447be33d027ddde1b7014cdbb5e22d6528b048f38b96f43ace514947192bc5f", + "663bce7335b23e560c1e82632be43791077f9136f225dc80705cce337ac42acb", + "9bd4f5a2bd8d02f576f157f9aec9e6726d4de78f9ca4a5b8de16466a4aa5651b", + "866b7e827b334e310636abe8292672e60587b450c2dfd7c459ddb5340fe9d4e1", + "3998ccb78330acafc87ab7742e5b20ec452f5b0144eb4674920f8396dacab092", + "51526a7f2924498dfdded52cf25a871219a69365dbe86ffe0654f92dcb4aabd2", + "5f19a489a4b50db5c07b8f0b1d1347ffd1b89478fc24ee9f89a24a670a32de73", + "0eb57f081e27b6f619e4d0d7ad2a59c09d128f790a1ddd347c4544f30e04fd43", + "815c0ba40095d51a1f5d5f6de59b98b7e0ff6bf0894afdecfba6ea5347b2a048", + "3c70bc553d2c31973270e2b7a36faacfa354b189c7634ba0f0dbfbe4050e71d4", + "aab4a36c0678aa46369e515f9758c097d6efae69069c4843d85ff7db95e33fdd", + "877bf4c5df0ce4a6026b168148ee5c80d839633611260b7b05cc58593c99ef0c", + "2510b09f793de76d02576a201fd8d53b1265f95c58c226b4e096702047732eee", + "51c323688f73458c6efcac2b8413402a18d5eb40fd2b20f4fbe75e84c5db8569", + "77c341fd960221a947fd62474f136bdf83b489852d2bf2f5bd051300620d1c29", + "201ae2ba503f8a98c8b8db9b91122c69731b04785d8cf8899886c4877197e797", + "0aa3e82b29b7e5ef951b4937a0019ed5199f1d843273288b21934d602d231655", + "70d9d76f7e8e4bfd52fbce63c0785b9e1828b3fed6edb39f3711268d595d6923", + "cb6ba623010855b3eed24f1fa9d0c058a14da1bc2db3919e7ce5cf0b5e734a09", + "77d4f0edbab874914d0f68078bd3c3ca9b6ff9cd9ef411becfa712dd070ef7d2", + "4c198a70c29d175a3b4adcfd56c2c829a5dd6a14deba22624e253787e5126d4e", + "1356d72cf3fe97d46805e6cc004475473253fc1c2f97bf0feb7bb8d7edf04bc1", + "a0327114ee1e2ed22a483db30a0eada1d1f015dfcf70359f9546b5ba625b0499", + "e9151be903cf0ad413d63089ac432aefb129e6da42bc5baccfce960eb3dea9bb", + "9aea2c41bab91e2827afbc07c9e55699d0953831e0d732191bead7f8c1e15593", + "fb847e316a2775dbaa7be3cbfe262ac07be6114a0d671e57ab34426cc015996e", + "773568b1e029a519ab2c874110ef9f359305f7e292800e24eeb3055ce3c0405b", + "54d62a9d0b66c95541832bd1e4ea787860e885c0af445f69a6f8cdc5cab0cf76", + "52ca6176cd05043b170bf2ba84e85da0ecf44d1e2465e27a1e89d147d85e3af6", + "51e20761b5d6c698db3245c3ffaaf7f65b1ea9f60225255b2bf70640b3093794", + "bbdcecf5b3dc1e1ddf04220da632d0f368632863aa71ab0a509c1dfc0968e9ca", + "683a707004566580de7f8703b16c082f16f5b8caf8380678436c3ed6abf7c4d9", + "f96cb5c177bd8f0c60a910bcba56c45ff82e7e5bc8d49f177f381dbb7b39c427", + "69f8d1e5a43bdfdd9ab7ed6057ee917e4f2ea5d970a3ec86d41e99079031cc16", + "3f78173be50880b71d3b0473391e6a75e151031108023a23ee9255783e3aaa27", + "6eee22f2576eabf6274bd1f4a32795be48a0ccfe4cd121996ef67f94e6d17a5c", + "68c8efded9265f8bc2f8b51e160c56bf5af987d39083b5b8ea20d565fc3fc5c8", + "43b84fbd28e1e7763ec03b383a6d3434fb0c93e0f33aa7eded7b466c1b84a3a3", + "d23fea7367431cc9bbaf27bc6bdabce89e5ca866372aa7cce115db768155259b", + "06a9e26a956c6c7b2db82546062d70c4d6a8633a899c40125def92a988772ea9", + "482be65a542b6c852098b526da236983000ba9157a11add21294695af0c2e1c3", + "95ed485d57b3983950bceb6771ed602b9a75724b4a6cf4c8663c5cabb1c1da70", + "26e87fae28b84659fe04354535a13594a1b1d3b4b69669584f0aa4de35d14d92", + "508133b9c88128805b5d5cc33745e57f1eb2aaa695878b9bb58f68fd3ec31d22", + "ce7f1a81b53aa582e1729abe8ccf5cf9e7c7b201f85bb54f4c3f8bd76148ca97", + "002641d2c38389d48268c9de2ddfde50d7cfd6012df0890fad21b7e57a50839d", + "5f986dfc4172541e3c7545a56e5b5c16e079ddfa3a947ca9340aa751d62c64a9", + "5c4801aab545b04c5b70925a1d245c9c3bff3a20d83ce34fcf6e20a8c80a0b11", + "b761f9ed407e9aa1df628973c86a32e70fdc33a88bd4c88d07ec09b78bafc1b1", + "dd4154c09293062a15d2e336ed0e76fa6ce12556114de7266977a4747ca86880", + "717e45b449bdd662753b634ab3a527c4b5fc9ca88b8c177f1c3709c887cdae23", + "e1972bacaaa205da0d6d39fa99e52c7d69e656dc9343255e5e99461b474ef69d", + "2f03a5ee507df35bbd7b88f98d22f5cef2f42f298f1c2f57af5ba6418e3618e1", + "bd611d16802f3da4eb243c41dc84e548d8e1df2fd4a08ff82716ee2ab1781a6f", + "ba9c427c1d37fa3b3b60bc48d2f95a06b2e434620275b2e51021102a23b3f7dd", + "65202fe70f9418ebc9e731ed5c8c7b5e2ba577b63cc55c28ee6505db5657a384", + "002a7635cc41527e72341d61dfd29e2e12beb576ffe57007b9ac0123816c7a2d", + "9c3b41664909e47301386787e16fb425b81df5dbc88bf69b84a2e71218f26975", + "10de06a4060e2c0cb291c9df50ababf47698d94b0fc3dc5185da33172c636946", + "5230a3635ce2aaa7ad4916447e8c65c169c1e30ccdfcd699b69b79fee7285191", + "eb8360d157c35643fe686d7c6b89e8197c28a655365b6398994ebe27fa22203a", + "6e14a2e0fcf309a2464d9bb262e8e32c6b29f23d1773246e24cc734c238608ba", + "e45cc25768f62a0e4aaa8352158acc9fdca742ab8032a3f98f6de74e05669c93", + "c40fdf8c33100fe42783ea3e2684aa86cf8aea331cf94419c3188064c44a0e69", + "b0c5a12fb52e7612b26311554bf87c4dd2c537b9e2b9abaa65bc18dec8ba0e51", + "67331a26332465e643221922d8a5912c45f0731f5b928f02b725a431a6922755", + "17b378a1f8a0b82e0ef76cb89d24bab124a8a39349800492d2b6d938b3d03438", + "beba8406c5c5f28ff8ab79a0002d413fa9d162577ab0a77c207d4fe08a3174a0", + "6d15e09bf31a1ce4599fd7f3557ce678fc042556c8375967603b2ff470b5bd16", + "10f5f0a3c278f46d5827f5f115e1c337b757500a94f02f826c497b34d0ee21d2", + "bd971435c7de0eb915732aac9ce69db4fae9fb396300435549ce49bde0ff85db", + "dbdec4c1e1974844781ad50627c51e416aa962cec179c0c353c6db1c6df810ee", + "93d0e48f2fca4508a4c53fa1513e3588b8eacbc8573a31cc49cce983d35df435", + "4b176a97c77058d79837a021a38aeffbc7571bac1cd99936580ac20f4e4968e2", + "dbf13cbb4e24d9b358b81daac765438d1c1d37e6d7f800582b7e8d886a5f6724", + "2f0c203001f5c72d0bde5bf9389291711eb24171555bb5732710eb520e8dae77", + "c49d60c369b8452f86be140333f27889f074aad4ceff16b1b31c96d529a0bad3", + "9b1530d6da09b5ac8547b0e0f1ae5054d3b2b82aada1563021a7425297d0c889", + "1636f81198ee8164234afbb9837bf06fdc085154ef701f3ebbb94242ecff2139", + "fd704a2717474a567685d61cd55bd8469e17d23f4184f6ba031cf25ea8fe641c", + "e476f1dd3279d2364f220f231b34f266287a1f01ccf2844b5ddef5ee40e89164", + "e359362e730dc475c34eac2a91705eb1e06c2e2427175b63df50ca07777b2e7f", + "5907dc72476aa02d9bb1503d632e5af74c1f35e4e0491717a72488b5e0d3b70d", + "4b3cb6bff033732e0e6028f3875160708cf98ae04354406168ab5fec9e41aad0", + "59ab3635deae62708317e3942a585cdbe80344316ef90556526f617811bea450", + "ba4a5b2d0bb7449f99b2c8473e7f1f7e4d93d2bcfe0bad62efc6a7d8b9a574ea", + "07a5e217edeafe99b79b3d1b8f756a78ea2fcd660bc6e9ad2c52a8ea71992578", + "e0ed67ce984d40089e69a832e1044efb87bc1571a59e24863002f4ae03b8f03f", + "27afa382d307d846d9b60a06a97b6bb899480b0228e70cda199fa59b297aecf6", + "eea07baebc7a0b2fc85cf3a99e7621a4f62128fb41572f87be7ba85b177f0596", + "947e5e3e31488d0ab6794bb44995108139a09ff2b05d2bd0aedefa35a9c23ba7", + "5b20ca4f020e8b423892d89502123e5adde21e964f5b50708aa9c2c1fdcf0978", + "7a1bccdbea0d256a06d73111849dac93aa81a0eac94b69a1e8bed1fb624cce52", + "269c37d3f12948a708e2887e52d58d520aeb337d7efbe0719db48ef41ccc5e82", + "a1928d7c81f753a91a32c80a805ae30e8d076c30da7169a894cbf543903891ed", + "da6e2bc69084963c14051f70cf9e807eb8d39b45d62d26507b12d72296588362", + "111c4bd6fd87ee806cfcd45c4f6d54666b131af563933ea0352d79c096231a65", + "a8c3442acf52c0e78c69582871d93373fda80a6043ba386dfd9a4e93f43d92fb", + "c9a5181f189080e99ec81e8c24ad332eb8036fa867f4e13476c59a9b8f55f00e", + "b882d4a95574d5f9ff62627121b3675dc754a664dd103b06d94cc3100bfe1aa4", + "fa9a54a754c7abdb73999a0a4a5889d1a5def46462d2c156e34b834139f361fd", + "4d3f867fbdc5426c1c76e8862276e274aca9e4f1f9833e602e63aedb2865e2bd", + "67c15f6fe29e6d04780d9dcc880a7fd9fa691e1197612dcd1b89d9967eeb69d8", + "209bc504f7352ffdda86699140d54650268a5043a2bc8039bea2dfb195196b51", + "81f213565b86cb5a4ae8c39aeaa60b1391c6cf65f95f00840ee07a713b72fcef", + "e8e44e63c4b9ace52d57aefabef29533bf4e19f80fbb26f716e8d605b89582c5", + "8b155a84e29890c35ca4da7979b0c2844b43307518aaa5b6854ce0b912bbf501", + "f993c7e84a747d735efa12026bdb08d4870c5c2166ad48bb2c5ee2f4cf8f01e8", + "33728d78ec02a36b589d4454135f29cce9c24ea1c0835717166378a7b89dbda5", + "7666dda507e5f1516ed56757f4d30a398dc7732a053385b2154c653d7f97369e", + "daeeedec5891de553468e53f0290e939ef76b0bf8c551533170627ac9537e897", + "d046bf877a8be28c28eba17d5d942c57bd383df1ba02b37a6bcd5d6ff56bdb41", + "750ef672e810c280aa0f9ae8412fab1ba76e9870bd32390dea83990cdbe5251e", + "111ed27f4b26b3da9449ac48ef9c749b2860f26c44ff33abdd3c5d021f8377b1", + "aaeee91b83d05c2d3a61f37ece1f61cfeb8c3fd2695a26591bc4d534417ce12b", + "61a9d12fd16915cfaf53032201a122996deeee777c713fdaefc405f6cd9e819c", + "6d38d366c776d4faee7dc505556278c3d8d7f7892618818dab9178900b9c81e7", + "3efba1414bf9eb493d9ef89c1a1343da1e63e3508132e5c45c03d7a6b0b83976", + "d259480da2bb49af185cfbc4d05376affeec1361b52e0eeb5d32292d4dc2eb7a", + "45ac83650568f203b441f3c63d4270d5657a28d0b9c00794a8093f18c178c749", + "ad9940dd5e72364d1194ac4f7cf4fd0e483d988944fd7807bb2dabbecd0bc26f", + "7dcb3d13eb64a4143f12143e9b2442f25fa4bdcb06d58aac04aa2326d1eb6204", + "ed748ebe8fada73f19e931fc25398be93e58bb42ddf33d17a52eb2d693aab55e", + "1849d191326384a088c562b0e03752f0cef92341d36ee99645855fcb7cac470c", + "57f3a34fff870b720185717e33add1e25c16a79553c97c0d35692b8e00269679", + "451e93f492d9b470e0b5e8576fe7099368b80f530418fee32ea3919c74426811", + "7edaf74c260b57140ccbba5238ce8c6bd330317ef2d16087f17e92d77b803f21", + "c0c98b35d5542a076f3fc3db0508cdc7cfe49220ae6bb5669adfe8ef83d3abb4", + "7713c30f12ee7ab3cee78bfe2617444630319bbbaa073cc88738763dd8ab2258", + "59dabf37c7bbc4cf977b13f4ba8debcd59e60a01179f269c732e6e8e3123d811", + "54ce0d6f7d1de6b208c71f9bd5b1a2be9f14126e5ce0e8e36cba792d2d40f9dd", + "f3c8953a0ea534e7994d1a4c99d981b9289b92cf6d8527cad9afaf4da61ae866", + "eb0c0c95b0daf4d27372c7c325a1b6a79019d4d2de9f249ebabcb1922f692688", + "9a5179a57523c06d7c963dd7d2d433f10fd68e694ca8515fcc4a15964f221d41", + "da306518e3d3f0e076bc0a9f47f525175e74c6b8b9de0ad05bf0e745241ea2a2", + "babd83c20b6d2f484d7ac24c65e7290ff25deb4bf2dbe028d4a70edc5606852d", + "657a0e514a1e4e30d19472d978bfaa74cd3a38ed266c52501729806bf30e3885", + "6f3f4221fbf6f3258a9370c375a8c2aaeac88c394999f29894c651723882a3d4", + "b07eb82305af1ca3bebcf5d8777fdfff1747160598959e98b05c31fe627c400b", + "7226ed8737be0e11716e3ab79a1e7da811c54dde24fc54634feb1071c7a680ff", + "cfbb2c3f479efc0433346d55f9d3c8b64d3dbc642528f2e9831d5b1499843ed8", + "75a96775deae4c7647abbbfbd2f0286c8facd89e3d7ddb788cc52681c763ca01", + "c05ca40de74c94a780251936ab1ab4751ea8ae11248ecd046bb67be708ce461d", + "7a326373c4a2b4be0c35d3b31d98fb6b8fb5bfaee9a5a0fc6efbb07f3123bad7", + "0a53e4201282e4cac8cf4379d010c4850dea0e80f013774c27b462e9961197bb", + "8518a67611a4c18f91e82c531d7e27d38104c462038a83a8961bf1b7832fa90a", + "2ed197bc6ec0c8d78882e27b643aab911f6d5155aa2c27a7b092e460520ad02b", + "8d507f0a08f05af628f527a8ac8e363adc2d7495585c7e18e4745b48fe2b00c9", + "e030109b9c82e3b2d8cf1690bac7cb15e68cd7d153e27335b10a90a032f9bf07", + "34c87a65ca0b3426912af4dadd4e6a61d6568a85be2a328482699d849f1e6ff9", + "96b6bd203d656bd4b7b25f2676269fdc0c6bf4f4a4556443bc63c24acf4f3608", + "05868b3f027d62bcf7802edaf186d8166cea3fa00d9eea8bc68c34627684851a", + "cc2d3944dac1de9c40d69ca552949ad4fb4622ba3109e3ddbe9415b5dcecb4bb", + "73a9e51d9fb2d436a453b9e6a86d8f6479c273cfcb534e042476fbf9274cf375", + "fedb7d82fd74dfb18e0deccd753e26a5fbeb63ed66a7eaf05a028ccb531389ab", + "c7c08fed128323afadee94e8fa54f9003e7ff5bade3eebb3b76f3a9bc169fc88", + "160cd418b0feaedb50405f7b577103d3089e55700c42be5b454e5014cfcd7f1c", + "f9e50aab90e082c75871209eacb29ba5c2a7a4755fdfa6f614a55e28edadb4e3", + "d8bded8b2fcd2201c3b791c79fae7ea8ff18bda4f8b2061d390e2d76ccdc063d", + "2d897a3a77067c5eef9a2d0fbca009566ae9b75e1970c92f6ed9576c347f6ab0", + "62301be2b647f63ab4cb9227e33723db62d420aa2a36f63fec33ef797ce0c8ff", + "e9574bf7968177bbd394201aa4ec886b1275b075f616a7fe60bf4258e36d5ada", + "f65ad1db1ef03d7f288482137d84454173ca888fd152667448cafe1604b87a23", + "f1d98d04fb05aa98c223ac3b77186eb9bd4c42ff5d3342b49e0257f1913476c0", + "565fad0951ccb1385a92c4a942e67bb11c832ffb046b891ca5fed1043a72a8fd", + "1e19efa146c6a337bc5e94f0e49eac0ba1245e6a58b02533ff05158f7c1bc3d9", + "3a068efc739b7ad10b69e64c8dc82fe6620ac07f3d1d60443184b7632d41f764", + "8d10f8d2f5a031499119a734e08ec6b3460922325b1fd3dd3f43030c19c5e67d", + "6aa45ae660e354270d0e177551c44ad196f6fa7529af50cb39f95429446db95e", + "c9c7f230077a212f1a92166023c1dc3055527313bfe2309d6a4cfe18fa8c2751", + "4bc1b1f59c0381b7d19e38c18b9973e5f88ab5c94169b7cca064715423fbd0f2", + "4fde5ceb3a6788b5d495f830008282365eb0f64db25aa621cf07c02091b2797c", + "c91d880c20fb5b6ffe0f4f28d68aa4b86c2436be645ec15bc20b53d47dc89c59", + "d976f75f1b1dce27c18605fbb0aaa72dac750565f7a7cf6733141fc0e115a5d3", + "55008c3d6066eb67b3300e91581222634bb7151668dd631e22d31652772e91bb", + "ed88193bb98c872bbd0187914e0bfb29c3aa6577f7894816756ad8d2f4138e8a", + "28b17835763b3af6ddf49f7d6bdb1dcbaa2f967938df4ed8aab51793a8ef53b3", + "83702391ba08a06d56d0cb2d4509d01a6c497d3a6cf9db6e4ee27a788b08b385", + "2224cba4cee58cf9b04a74da642e7ef3425c9a25ccb3adc085d6dc9abe231ed7", + "eee2007a3f073182ae62a3dd87bb27c20d596a98c2c37e2f85ec3f370d673602", + "1b93b8ec84e7342e27cea1e1c6a390ab1531d74999b32ef5aa5e261b402427c8", + "00915788e90558657c3d288016a96fc2e93c921ef6d84df514ebd54287bb4125", + "549499ae488968fe78fd596b7134552567a0a25acba8e263b50826022b285985", + "8c180c1443a521cd1ab83d22e07b54f3d621e9d5060e2b4abfb7b12e55db93e5", + "9455776adfde9e0dc60f399766335f2d71fe06b2d2f6a96192368f555ea5dee0", + "cbe4c921d2d2be9f26bb6398c3eab4e58ee77f87a5e4f8706428ea063c8093f4", + "af27d82f525f274d861be78c4d9de9a5f647ef90524bcf361056b7a62e1d3e0d", + "565ce02c42ed3c41647021be28a82405523da52632e3584a4768727e0a9b1ee3", + "fb8d0e47fdfc08a262d60846ca5f692617f22a228f1cccb4a9035ae84b60c40c", + "608311d84883f64f45ec8e6cea5057f714a6faea392dbc33c9484c4830ae51cc", + "30ce0d98da41b44bd56a938f2d973d79ac8081bcb1aa1fb51a7288dbc27faba7", + "c31a48636da345f22543c7f5882057a0ed90969d94cca2e63dd78efb945ba1c7", + "b35740832d2317a1009b44781c1ec54bc24d0ad3c288100a700111b552c941c3", + "adcc74003d799ed004ef6fd5ba18defcaf24bd6685f24503c8934ca3e5edefcb", + "f66179c80546c629b7cc88709a91439a0a2a9a344e6354b3c1d07a07967d50e3", + "c446031962726196a87244760f03a446c5e9f47cd6b46be6981ee7f9a0137761", + "1ba36c393c8ecbec20ab295a0ac4786ed0623c0c6d66b5585946d790ae86dc1b", + "205943120fe4be5bc0b05e7ebff88e5e4f826f0fd16e1eafde7dae8060ce84ba", + "319c79c6cbfe42abe010a91b6aa01424f41ebd6ef50be88491f4bb2a79e75a3e", + "dd90f2d83f440f7e2828b37d4d0adefc83e8e3b9aafd83e55966fcf712d674cc", + "631e2c72087f515f2debaf1a87d6d87613d20cef90027198af41a6133d7e1822", + "2b30c637a8eeb8503e6e722b18f67579a387e56ed44745690d84e52af2e1c3e6", + "8d1df619edb643afa64d41ed7b50208dd2a2cdb2bdcdc83eb6513b0fa89a267f", + "4a9a6242fafb9093c59736fa301722ec7a82a73d9d88785dade0232677cab2ee", + "eaf68433697020b410a0b42fc0adbebafe25da288c9fb329931881acdd394141", + "a7a69147eac04ab702b674724f804c8930e45c6607881277166f31535a74ad50", + "2764b3243a511bf85155e63e7902a400a5aa7af09cf0fc5af431c50dbe9e3d75", + "030c77649c9696e2f5ba87c85b25bbb5a98f0e59ac0407d17e8119287b33baaa", + "1995edc46960155d39997a956c396c6a812feee5f63fba881e657b03ee1776b7", + "0127acadf023cf334c3237f1b44663872470dcfa4707aba98e3872ef29f62fb0", + "3cee02bf7f01fc510393038f8da5d38f2fe1c22eda9b55acdf60329f24e20be2", + "bd83bf6110bedf901c6e24f9e475b7245df81adb13ebafa9ad898e308e38cb52", + "b2ce89f8a166444b465a342d64ddc5f62f022761ee3d81daef34a94fd72d77f4", + "83a73d6369849c8d020646c90c402839e4e393d1237655680da6e7e16e5a8474", + "5f5707f4885341e953cfa4b45a6fb1c9a9b2bd33158bbbda2051e8dfeeb7d4f7", + "38eac3d57e2cc1f62433c909652db177c3a262f8a568c7514916aa7dcc33a200", + "a9e498a21762dfba2180ed64e6fda50f60e6dccd79eda02b53ea20a58ba6f341", + "af78f19e17792c0e5d31efb83cadc198b7a7c782d010f852048300a76e7db3c8", + "8a050c8bb4afbe1c4ec128bd2b4f73a39109a27a9d3ba940678550a6f705578c", + "ef5748295ddc7d57b60d2d5e70e81f4507d21b63be2c1713afe5ae44c3791fbc", + "098c34ea74da6e0fd54220f5b01d0e074934b14806bd465d2b5427465cf71841", + "c903303e548e9028ce4decdd86b570499066d86c94dd551a33bae3cfc7c40c3a", + "18b2c340875ea18d994d1478bbfbb0411e24b93a6f16d1be1af4a44c360e15dc", + "fb03c664789f9bfc1ca28ce99fb178e1291e26e5a4ca07fbe271668038e08b78", + "83e1993e66525db3f861c815bac1b98d67a525a1d8f1361ce4abbbe6eef88a96", + "999593a8e9b1cc37f1358baffa678f5cfcb03de4ed1c3e12ca85c916a34bbef8", + "87f767d9168207543d611aded95b36b97b13e667836a25a2c07f86872dca27f6", + "6c9b42333f2c3b22b299b5ebeb17a01a88620292f23157c5f3051442c6861404", + "69db9921bebe596baf09b3338b5223f5be05972468819d6ab608a69178ff2af0", + "6a220914ba38c658cd20c363c09abcd2784b0e7e98d4e2a8d295d3ea10eeb775", + "e0717197df92fb7eebcd2fee8ae7aa45930579f1753b191b3eb7585932070a9b", + "4d65db9bf1d7c936cf0107c76301d06c59e123c779edf3d13ae7ad73a7a4fca3", + "9896e7154acec062d207d23cf3c9281ed9eadbe618c2c090f161033e376f7c70", + "a68bdb2354111a11b685d6b42b5337b716dd3eb7405099c8fdf64506314aa530", + "f615c8be47948f2c9b9259258548b21026eab4e50ebbbb09c66755d903ddd38c", + "be70a0675ef918f8fbf72b4c2a6217c0e8a1b29cec96f38a380cb8c61b31b79f", + "6f73ccd9126064282befc8b922c0e959102c4489b4f8990567d2ec3a6051c6e2", + "25d51e79260dbccb27cb452cf80523025b52419a2df2157cd17509227ad4a671", + "f27124882de9130349389eae85076b59eb9b0b4b3c04b943c80bded8a43aca37", + "aefbc188a9d8dbefc8c06ebe795e7098bc8548b7800cc21890d6f3652a64f8ab", + "0562d728ed420f140ebbe7813cdd8d99c975ed3f1169b890cd76c2161e3ece01", + "e983426fe4732725314e5c4cf86ffb4cde6116e3694bd20d0cd8486c414b6e6c", + "bc67bf9b1eb5629c46fc849858757ef7a6cb67798619aec00bb373f550a49401", + "64964a5c78ce8aa2b68b1bbe636d5fa47b3fb8a9612fba9fecc05e8740a00dd0", + "6aad0cae02bbb49db330b610ff85706694a075f24a37a04a0b30dea6ecc57be8", + "885914a911a99276a93d8e54714ed77bd902393555348ae59364a25951c45097", + "a4d7ca9925a707133e902176bc2ad8e6f2a638c9289a370ae20857b2f9bfce5b", + "3439f57d464c6ac00aae74387cdb550e437cb5c7a8842244276b0be6b0421306", + "5606042930605947a6a9b16106e68e0e4d7adb9a95db9c1cb55b19067e4bfe43", + "0105a9c7fc9d00b97de14bafcb1c245bc072a8632daea49d1fc0c13a5a1e30fd", + "750e57b7f4d24c68f7980e4cd39a4bdaee0f2604cec1048f05bcdc598586e32a", + "25674f021a5a4a893c4cc3a70f88bb951f5cc6a778d247fd48ca9c1c3cdbef09", + "0a2a9684a04ed808ee703d167f2f4903035417c3837189b5aaba389be767e809", + "96e5fb2dac3e6910d885b67a60db446064cf7e7f3e0d6f2880ab8e4e9e8fc27a", + "bc57a1a37a0c428dbb6443844e668f4fc654d952425c6fa9618eab3b2ced3635", + "15e0b077005aba39825030d142849098833027f575cc2b144212ac120211cc0c", + "9a4580bf7e3ac5dd01ff74e11423d68cef64c9c7ee46ce4369f368a60d64ef80", + "fe2e48af158ea74f8c46b6bd4f245de6197436b4d0977a48cdbcc51ff60949d9", + "1e73ecfec4ac994556f6cfd906f5a3e2252824a3190f0a46b567956ed865918a", + "48bb46a5f08b35de42f40d019b486255ae2178989461368c9517d67c0f1aa530", + "ca7d625d0ba8fc48bc072244ff0e0c78f9c87de5a0a95f9129be3c632104f59d", + "a45aaa89408bd1577329efebc9258d180805bdf954dbf8311af4c5ccd67d1837", + "740953a0572bcd42e52096bd3e23367fa19ad919e0a2499055c48451ed347617", + "d36107233423250e95c5a1cc97147e8c9bed2dd0e8c112a10a8116d4179141e7", + "64966538261ce084cf9563b28ed8f5d16ebb0ece8259aa61f9541eb160c5c66d", + "ec7d7f38dfee19fd20af77852f55db90925fbba995dfad16b01a62d682518108", + "fcfda11ccac9dea010e14b542b5a0edf4a25ad515f97495a8f286bdf38c542e1", + "1403212f951016fdd00f673a8e32badc97b6c54f965ed20802736e16d4087869", + "a40c968e1e40af78d76a9842db3ebc7ea1135d09935c912857f28b09ab528f17", + "dbfd95abf20e264fb8347f789fe4facb700604f7e68cf35408586ce4fe0cac71", + "596a5d7d4b95ecf6f69fd65f8a21f1a3996483b210e68f6e43d2e3abee860e38", + "839f36f230490c5a4317c487c896154c15cc3964036bceb3e3b7e90aa3ee161f", + "6e52f561d9caf3de9a317f07c266cc6fca0959be17b13b145d65dc24ee18eb0c", + "b1c62acfccaa818c3d5c476869703fea050f855cf7c1d09f417008d691e0d59f", + "8614ebc5edd7b406a6f494b694c709bac3665e96909ec8c26249aad938c93a0c", + "48768e71cd69fe3e2e27b8d9a05873302be3e9fc8741cb747a1f4bf35262cfe2", + "4506a925908adb6de130be44c54c3ad27ecfa27fce39a8c54f1f63696a00cdca", + "d9205a49bbb4edde240bef351c28958d35d98f7eb37c7401192d1f4b52903ead", + "f894b8d1b3e2f8eccb40f7504577d1ad40d0be0c039b29ff20e7037e9bfce3fd", + "03bc8920163e808881413335881181be4b8a64ed3d9f0f1bf93f59e92a7ba0cd", + "969be54df64212729fb12c1963c359f836326657b47f503989ac2d554361b393", + "0a1ce6420737ce5169f435a9d9cf5d34046e86e91944acf993ccf22f36aefff7", + "8b6ab7f4576f7f6da8997c7bc03e2e845fc18efc3d569691bf2a7674ed376a8c", + "c09dce2c55f7a7b6fe453fe72d20e007bbccaaca6010fa2adf79ed1206d08818", + "09524f3878ba6113700206012f6a660eb349a5e9ddfc110da10522330c49f8ca", + "df939005dd88cdabb7a79ae822bb643d33b5397c2eeb06e45fc1bde0b964b780", + "bc304fc61aaed2d695d4ea67ee3691e843b6d8cde76db5e3fc021f46a1ad4fcb", + "d7f1779b73bb943a3693f5cdcd8115b9ec1710b7674b98c4a3bb5604de5fabaf", + "217276473ff67670f0de76ac4672a43821c52a26a646870fa2fde89be279e23c", + "6e76e272876d7fe990e5d2afb04cc94ce8fc57c0f62806e14e7d51bb13c70601", + "9eaea4fd5e139a8f9e9598d6a0e5e0ceb47084cc7a6de4af7bff1fe64a9a5796", + "26cfe64af4198d60e64f9243edc42b2e40ebcdd575aa38accaed856e7ec7727f", + "c48b241404b87c38c5a6fd91a1751659aec871e8aa1134a22b7f3c74a3ff7465", + "c1c83b9d1693cf246e68c6bec149621f48d117dfb52b827007606009b863e56c", + "3c4a05627cb4960982f9da0e45541b6ec1b6f84fb5b9887a99189cdd1bdebea7", + "b0bd785e8819aa04667e893454417b7fda5b997cf043fe24bf86fbec05c85570", + "459c5a34e6ca24e3dc5ab922f2b9677540f3398371933889cd7927c626eaaddb", + "08b266a50d0588ea254e418e8b37b3e24cbeb17bafeaf6568d0665eb167dc343", + "1973becb33833397fd769ec37cb672d5ccd59ad7bf3f342ec360d0506fd3330b", + "f7db9706856d1be3ab5ce6e7de775c1e4b5cb18e2b55420ffe5d8c5378830bda", + "301d825cc77bee3046f7a49a05a0632730d29bdae696cf17028141555f766a26", + "1dfcadc0444f4b28f7d4eeb704a0e92a04ced5d2a4cd10a7653916e9d96c3d62", + "1e9fcd9e415a10cc13117b425a9db6e06252d63640ebd2772ce3407072ee958f", + "1fd12352354222fcc13ab9b0e9530f63da2b47e470f0b08c653f6eb4e586cdd8", + "01155d66e3cf6cdca000ea7cc580736f47ed93aa6ccae5626b233a9c53178247", + "0d5e0738af6d5f39e6469b54fa74e278b238d6b52ed53c7b5aadb2b9e1d6d47a", + "dd01fe524147b17f4d520560ed95001cd649c28146f461a134e515e9de1dbb09", + "8421a5b75469f2645cb3ccee2f434b9261c84274ff050c37853270cdfc6ff14b", + "95e5bfd5fd02654bd7f9404d2daa98d95ef52548ef368b2d584ac0df68a4eca9", + "5d12ddc833cb4965ebcbb0624319ab2fe903c580e5096b168fc6e128e579a435", + "c89484471c47788850b10b7a8d86d52616fe15f7c6552f3d1b73907ebb68212b", + "fc9e01d542332e318412c0bf6a5b134920f0ee95da76842615252afce365321c", + "7e36c06ba4708806d37d5a787e75aa2853a7e77eb000a14fd3b0f4b3a5dbc6b1", + "2bbb8b4c8ec47c1d125d02f843e287bac95365c96c1ae63a3fe231122cfe778a", + "89879eeebbd8e39c3f2c796c6ec8b854eceab4f42b6b839ee962daa7cabc9d38", + "1b16da827db7ba00487a423c7059833ddf0a6e5db7df5d3f1f0eeb6f6f72de0e", + "f207d419876220e9bab68f92373040ef1ec8096374b4d1e287d46dcd0470efbd", + "3d73d5c50bd58b61038956500381d347008fb25ce13df3cdbdf6358c79e87ad4", + "fddc1a900c9128a8aa282c0b00fdf0d591bfc16c620176652763904d537c97b6", + "c9dbe8a06e58e89c315b2677ae5c6491b6a47e0e76c3e714ecb2b1b576a6d694", + "df1120c248778b407a457ba9f4bba150a601f1d5571a5cb46f166de95fb1f860", + "dbb5e0d7bfbfc9d437d3d95888608b7a294782799e45afddcd61d6283ca50f4b", + "48305a3728956cd2eb4664bad14691a66539e5f4610aa3fbdab8f3c10124c310", + "97725e0eb36e5fa755f778728b99d99d34dbe127d9d99b8be3179bd8f2245fd6", + "8ef6f504c1203888fa4f4c6a08f226c45d500b8d03d6ff381b57fb0e3e4f633b", + "15de64c9efa2642abdf113f61c5c2229456e25c4c7836bc5901edf55e4d43d91", + "d4b82a15fc97aa6193260ce3f153282b6e04d6d1d5efba950af7b0e1bf24da71", + "c83c1f0606d69f5fd6938a8a84477286d460b1e0ce07cc6106105b181f3b360d", + "24f644c19ca8bc4ef5ba46ad46fa35e79e74b2c4a3b0d3feddd4e95f90cf5f91", + "320dae24aec56aa5255dc041bdaa761173b3155cbffa126799bddd3f19b2663d", + "f065dce818e35ce631a87842c831eb3fc1a3966b5b063d5c3d6fd13e016c79e3", + "1c96ed40dffb2c8297db93fa8eaec23337d81cdad645483d9bd56392d6c75acd", + "d2f24d2b640f000aceaf3287a7f50a20af50111fc7d7f1fbd4c84b06900fc949", + "911a1a321c0a3ef78562418fd49b964e277bda6d0ba9659ddaf6ca00986d7766", + "1fc3e920d752425396478f40756b55e426669c239f3c203fbc868bfc9d6a4020", + "f6f451d2d5256ae04c3dab8cdab27cbf2dbc5c46b4ea52dc72721e8fc9752a6d", + "6a3ca02409b6aed2287d6535004a71b5dd99ef4d21b4df1b1e3df78879331f45", + "796e2246e69adb094b2c767e156ebdd12736084f095889c998a4bb99cb8578f1", + "26c78aeb26f103aa153318ef04b38159b6404ee886f715f45bca857d5c274fdb", + "f2934aedf599b6b0be0c1e27eee0571d4b3d047f08266b6df7b65ccd79358ba3", + "48b3a4059445de62909df1a3641815f36510beda54aad02b54c0407ea568963a", + "ce2b9d52522d40769a8d1ee3f70a925055e90ba4732742e36825d9973f98750b", + "5163311f2fc7f86b8b4eda6384771085d04f0ff6a9a0122e59599410b67a0f20", + "13af520fe1a460a2d4eda7c547747d3da94b54c8c3b40520aa3f6a3930b912ea", + "cf81b232acd43721a9c0c1af202bc1f058bc4a8f7dafec9046b1cb866b941410", + "00aed280afc4c03997705e235b41005f2c6a4e58b50f01f62a156b9a1493ff79", + "e1a05936d5f4249b840c6a1e9f0fc85b6e6f2789e6dc8dee764e78ba10a81101", + "42cb843b4000bc80c2dd40481aa8fd02f7d32da61f1c83fe9a806c56159ffde0", + "bb2f3151a5d6a7964e112d843db5d7fafa98a040b90f53523333f6de82a700ee", + "b14c1b8b82fd55d07fa0ff644f630a01adb074fadbe89185f42c89390d02c20d", + "88dee4f14585b5dcee0c561204428995c7204b61136f7d09da58066851ee6ca0", + "10a2188db9e5335d896754e7c3322e93ccf47b9d309f54c59ecb0f8d244d3a71", + "df76b51a130a97567517b105efd001d1e6ff0b8b5280b438f4c7a1ec5a5f927a", + "ce1a7977e067d78f4398bade4016172a17eb4f1fe13d8c797fbd7251397ffdc7", + "0f120015d2006fb1c48d75bb5b3c62d75e99c17ac222f8371fab41af73cfd474", + "7c688d5d08efe478fd47beea399a717b6fdc3605e7ed7fafdb4c5da6dc1fefbc", + "0f315c9774a3b677b907ee070bfb00fb6f0dea4bc1e722b7efbba18c213add6a", + "5bc855c1af556b92a177724c561c5e9c29ebb13260087efe3356582e5817be54", + "74f1f4b538957f9767c92ca8a753c2fb072edc2d07dd489e9e666a79a077018a", + "f8808891d9160b2d8ff09983f1e0f5c63dd4aea2a4a611482b190081db1562c2", + "69c635d05991c52dc3143560d9681f5281b40af2846be0e76cf6af8bfc86f051", + "f0c5d7adcfb61c110f5ee3c2b678d0d2336a48c14f342741dc98615462e811c3", + "4b4b2abe6e9ff8582d235e5518afb17c4352a316d2625786c864d94ffd04daa5", + "ade3dfbfcf8787758f602b345f95ad0790a084edd105b559fef1068066292eb1", + "59659b9c28b7f6dd370f7fb97739b5616c325b634c96038df438071709beb1c0", + "fe1b7766b72a12ded8efe17c1fbd4cb7f4068994f6e2696223c3810a70f1c535", + "8a20c31a14860d3b113b3a3bd18f6edbfb4922944f9d1e078d859d02646d0ac5", + "bd98167d9430c08e0104941f6db2556a8e341663bbaecb664475e44e86a4c3cf", + "45a66d220281c491893682142a9436b64b88c7653875bf9a96f89de72cf3eb59", + "1e4d07c7476078a07feab95c2186bcf39a1acb1234d19112f4d4a05c455cdef6", + "42345efdb9e8e594b444e6a064e73b8f1a0e62316c2a91c4add5f5952dd0ecc7", + "e54e2184a318022d3cbaeb75b5651f903313de4cef9b6034f97c0ec380d6991f", + "08de62956ad1cef91d0c96e597a717371b4c2e80ec7587ac0e2b90912c0d211b", + "91f1d2b3730b6af0bab9827f16e571f7160174ef79ece243cd213181bfecb18b", + "0810c404bb1a9880316c4e3df99168e290676170cab427cc55b89b5dc55530fd", + "b88314961f2256fecf99c1540fb51572665ab469cfcd7c76dea70fabbed460a4", + "1eb88521c71a1363e866a3783a6119c4019b206fcdfec85a394ddd9b21494495", + "2ed41cd54fa28d0b9bd2d6cfef54911b558139a12294138cba11767692cffd7b", + "d66f3b3a5d172d9f64d8f79f07b01d12bfbdef1f3ac9980bd7a2643c48b4fdf8", + "5c40dde377ad3aa43be346284f2ccd268cb8e83fca07aed279da8e4bd881a202", + "09bec65b20f62cb97877ee771a69215946eda8106ddc0aee956e25eba6577370", + "c6c46badfc140fba2507f7a2d543d5fd5909a86640688f1fb56d21a17aeb04a9", + "c5d86fc562f9c705cbd33ec4fbd79e13c312905d93132e21738123fb9e52e8ae", + "d975977d8c3cbddac106e075c29f55cda83dd56e5bb46907194ff5f5e8f20fff", + "1aab347421145679f5e9788c641b00f0002e9032e9019a002441bd8d9107efe2", + "c5a32cbdf7a3dc680ff246d4318bce7047f8d5ce7edddd04a471c5083cee7cec", + "1ce182362cdaf33597b98bdb65cb896b759da51ef21ce88e3cd107ea04ea948e", + "1da0c439bd77167fd603d6a5f893faa4e9d2ad38487f30cd35a88ce0271f69b1", + "d5430def02e87e5e857714106d48e6fa9a56a4f7e578e2871a710acc4d4a93e1", + "9ff5bc2e0c6de56f257433376184cc3b06890c8832f6cf519295fbbba8d1be5b", + "ae2ed76089bd546990e3242efa3aad1da610f966011e3dc02ac54621f1ed9f5a", + "c743ac97834c56f5f0a9968b7ee16cef8b816289d69766cd76a38d851daa2416", + "af7f5e54a5158586c585dca38042382d2cea37a49dd9e939132721c6639aed01", + "c5423c2276150852635083a33d1d70acfd2b23a016a8c35ec1c9d16c75202a7d", + "3767b73782747d92a2ab3adb2c277d03e3c0284da86e054b6f7aa3244b32c20e", + "f20e3f4649a857554a5b0393d12fd159a22855dddbc4962a4a127647dd173603", + "2f39a554678116542fc588c4067728484d4ef0df8da3d2697473c616cf5038c1", + "1cbd3cce3fa8631af7c14b8e529793c52208e7a596bd703d0bd9d58e4f4a9537", + "2753794b6a259252040892f51ff56d839b5d09dc963c68725492d62e5dfb7556", + "1ae2f5a4d72c8a3ceedef03767c2fc7af1c097b3b73f1fb241f9d6ed50948f5e", + "3006554ffd265315655116445933808fe580ee681bdc7b0d8989a2aa14d18872", + "51c635df967560a49b0a5867844cd216e77c87d15630554d4df73648a226884f", + "10f58c432d7248c1b7f1d5ba7d86f443bd7a49787408760cc2063c4ddb5dbe94", + "e10479bdfc6b62ea9f1650da6bbe6ee8d9a654cbc4b273cae607c539269a34b8", + "853d04ecf1af77ffcd6de5894584aa33d33f9157e0c026c0a81ec775f34b5acb", + "0e806937f7b6f18114bb08b4f7a4306e2a0a5f7d1c26a85ea03b29daff1fedd9", + "b5f0633c36e467252a2a2a080283d19b0af01adedb76c527fecddd835d6f431b", + "3f558c49486da14dbcfca7fb60bd7b11add5390dba7b8bcbd6f0d8d5fb78b792", + "6a0fd06027b825d278cbb22c2216ec88a885063bde5813517ab2eea94139566e", + "b5de4ea38cbbfe462f93eddc29e6cdb7c936241a0c040788e21488d4903b6960", + "42a8cae8f2384fe6e1e1d76cccc7f139cb07cc5a2c695590a9fea19ba40526a1", + "cbefd9971bdc746fb3cabdf24de1c4763b6818c5e152b62b0578d228bb59ed7e", + "c6c5b4b2a6565671bb3d2f56363cba84c7200ea4bb486781dd9c3153525cdd47", + "0c34e872c0852e791851d7e35462363e1be551099508e502cc7b6fa2ac6fd8a2", + "c26f46527a11f73e685131cdc1b15d73afd8bb02c634e47f61b48647b58ad354", + "d0b9ed3149b8b6ccb81543e656bf5885e95b2be55ff0778f4bb46650fd5f9995", + "2d8ba3d6aef946fe14b1ef084d0d8ce700f766c4da428ab947b81ed6b5b922d0", + "bd416a2ef56dadf61c14930d16ff488c2b8d33416932f2fd347035159e4b2590", + "5f572456a266226a55e02bdbf09912a284c5338e549bc7589586924982b90996", + "c330b8084374f3c68ae0ae62c5bd42f89fb8372c6da7785495971c182f1d59ac", + "a04ad5f327dd12e4cbf600e1b849da4f0b9a2ce727d71c4b1ca5af0b0fd95390", + "55b98c1d5f30a4731e41904cf6e9cdd5f0c0cada2d39a16361d0ae69ae593412", + "0e7d0266bfa30168d078757e5cd5695925f10a3af8afa3f3d6eef07fa59f36ab", + "a1c2826bd65ba31ce10f15f0380e8e13bc66fc4b1da8f4cf089fec169fe5c257", + "6f392faff860ee7b447e809b08259c3930fb4137da04f74c699f51b07cc4126b", + "5417c55d5f8a7190911f3988576a4b0e18101b8b587903beba35c75c2df6a84d", + "575169fdeeec8bd4f58385bb419aed9ea46961163729d37f8885c64f00a5f698", + "5c0a6e8cd261abafae36a86fb69856ed9f4f2d79c73c1bc58f00bc8d725a9c62", + "fac418409b082ef70f7f64cb27ae42ceccb64c231c0d18fccae846022c912937", + "0cafec3f392b49ed269085306a452909eba50875738e028af5195b3cc097cd13", + "fc8d4c9003166614fb2ae867345319416d6b570abc96614edaf3f1026c1248f3", + "c04ef67e3b74bc912e8f2e26d27afe3d4fd33d12afcec1309562f11da8edde1c", + "79461696d2e33385222e1b8d3bab0a5e402e4b29628bbc8a1c7035a33556e296", + "f236f723f31086f60475d1219e88012d283d15da0dc5507beb341f6d8e10415f", + "5cc206dad9d140f3ccdee595e20987a2e087eb6614d24ee714d74719a8cfce16", + "692bfae3698bde39d3fb6884c22907093d0dc702ac33579ea7be3bfe6e6570b8", + "cac9bb52c1bc0c436badc76278eed82621d11dd8ecbebf260b7d6c78b26a2ff6", + "e5cf596f23f620885cb60376f43a9914b6b46d36e4ef1478302e3fc66a6ab5f7", + "9bb186eeeff59b5b8c16ac6f5f51dd484aba838c1e4757f14b6f7de79baadb3d", + "5d5fffd2e62acd860a027db341e7904bc65fc7546c1a0427b9237d6690f6409a", + "abfd03bc9a6ddf02fe9e794ea3fffa40159bc07eaac8cadca81f61cdb35e6b4e", + "10a697ea929417c43813be35396f976b67fcce454bd8bbb5b1adee60e35160e6", + "995deb161c4dd33bbb58d521f997d456d9c1c2f7faaa54615e2168a05c593734", + "02f4be8a7f2dfe14d346c914555a3061164ec03ad1031bf65464d170ba8bbf96", + "63b134fdb14661906cafacbe0448a1bcee26e5f0dad4d4644a45f3aee70923b2", + "2961abb7332cb5c9a9b7c6792131288fd1ab70e53831c05e3cc92cdcf56da222", + "7d22e17e3bd406963bd15a97fbb132bded55fb5e9ff067015d0aae1549f81f90", + "4f71dce27d1721b88cb3cbde41be45158d8ad195d6a84c9b93a519f3e4ca9d46", + "0b2f46637b8c8a318b22774007a8b47a6ac9d48437c61c617966a1f9e43ec1e5", + "f7d905b1a9532ddcf91d49d5a7ea7c1f382268dfbf205a43c1bb85f5b9be3974", + "223a5f2173756fbf5c657ae0025bfc1d87b385be7a97e439d2e94d3fd1913ecb", + "dea6ac59fff5e7c40b25a12e7bf2430e8a63e522909194fdc3e8d5e8b442909a", + "b48645435d33cace1d589314883e81a91b6d5ed386017d2f3680cf97c0100d20", + "fe96b9923c7e37c318ea361c550a8080341433e7422be2b762b95fc1f2cdb184", + "3b1a01a1d9d932663761315e67646719e0e23e51c19acf3b9dde44d025d5e413", + "1c1be365ecf1a8f45298d55e96c6f058221c99ea4fe838ae16854812abb4536c", + "6eef0f0253ff97650e2e87677d65a1e41b02fd9330009762efbc7333178d2133", + "c08a28bf9696888eade20b7514fcfcb8e457bc224f51410e9e012d7cdfb701ab", + "1632e931706ede8ccb19d0aa258223dc68236072be5ff18965ee2a543930de00", + "0d6ca3073a121fd4509888a94213c2da083972caa1fd17d1d9952fb14296a589", + "83a980428ec9e9b8adee2973b6c93b20e64482c911b718071c72b0bfcaedb224", + "1312535e74899eb3d022cdd5da6eeb4cc7462f374f6faf434805c3ec0fb84f22", + "53238fdd09ca194ed47ae33aa646c48047941da5d8f02fddbfc13340eda6bbc6", + "e7e49a2cb1efdaa593f37957cb5e44a345025b92a14e01f1d3210280dec5217e", + "43acde052e75d7cf894d935c74e4ed63d8928f01f9eefe86a20b1a329f76ce6a", + "9d56484129611b5c6ea7ad5788168ded4e7051d5f363e2363371f4fe8f5c9377", + "0164169692e3e5c7ec98463d4a005f81f7855ab8292758ffafdc2954708919cb", + "74eeb814ba7abffc624b66028d57a7fcb671ff554d2acc1946be5efd23489053", + "fe73de5233c4d17c40cafbbe8880a9fb09b0a576b22a4f76d57fec982bf6b67c", + "856e943f18bfcfee776dc885eb00fa2149df7364cc86679d860ac5614d79d829", + "da14006189b41b61f882cd9ef4ab3f723e27fe8ab9378b1eeffc0c64acf59b09", + "edf0c67b7158e53856e059f46ce7c0b6434b8c50df83a727f66c6a235eb11ffa", + "984a1342fa6d9dcb1b308563e95fb2444de6c81327e71a3429100bd05157470e", + "b53a0b2fb117e8c4cf8f5e00a4b1b85253e601c54aeadb178e46442badaaa3cc", + "5d7f0bd4487cb6abc8fff3ea7da3d4653abbe45fda609f100a38ac35939b04af", + "9ecc9fb37c5c8b79b82cf93bd03634cf14cf2eb9842e30dfe4129d0968166175", + "98907176453166c43412e64ec8da624de18d8499266855ae90c45671f18cae48", + "d7added37da412f48d7adbad96051c5b0d41c75c1f63c21e829913e2a4e48329", + "72a07beef5551ca614d324b44375ea9f316a2d7206d26069490afc702c91df64", + "bf22255d5b3020dae0c18acfadb232a4a8537874ab0d5dc363bc6ad6d1dba020", + "11e98c8bda705c67ab21e0e8f4c24d6d1228f9696a81d943d1bb8ae2c209b25f", + "4c651ffb7da202f105659172a72a1690aa019f4578f702cfe457225f286fd39f", + "ffaaee2ee9d57854823f4124cb854628c115069a4adc6dfc40664c743fb9d499", + "8b38f9730d71e4b36697b82cd97806b11804803548206a1c48a9c20ca783bed6", + "4cf4706c169f998d4e38e28970d87321aeda31755be4cc0381bc2cbc6a6dbf6a", + "d0a996596823558b8ca374fef9ff332b48714cc0ed34753899da95169a4fd6de", + "3a9edfe54e08e4babd3f0af12a8ec211a582fd432c8cc62273122832a61e3f79", + "3d25b3c94cb73f025a6c7ff60af06fdc0c96084ed653d826b43b259a9bd603ea", + "526af906f6c94f343d1670a28cfcb73e56851caff4b2a7a09caac4ed3033ff16", + "396cef99d759cfd4277e725a5234f033c3bb0e27caef3cf2fe60e3f2155a0dd5", + "bef98348ff5eb417b2b0f8c650e77dbae66f88b966123db57e8655f6c527ff8b", + "dae5c605577564bc2ac172dbe10a86394a41f675692ed78a386fddcd485ef919", + "d47d1efc6f657fad46ec2ddd804c10f48a6e416dac9c84edf0e729cf98661eb5", + "47119f6a82bdb3b118d0434189ed77cf9b8e968972531086ca1181fcc6b92d01", + "cbe8f209c03de3fe2a7ee13503a0cbac2e7d700b5aa8a685a39f6d5ae40d9ed2", + "eb6cf81b04b2105d032d4117d5715f705ebcc7835c0409441ffed7713771ea14", + "801eed48e6c8b8ec7b44dff7d075f46264ddc04cf6dc13509b86b5cd4da10a9a", + "4761927d0ffba5eb831125c53dbb733c21137f25fa4593bd68fe25fb1bc26739", + "2549125eb0b359117dece06af56bbd2af312a2b207a2ec59a4c2d278ee3bef27", + "db1aa64ba3fd4922484abaa8d5154e5d44eb1f487554f4acee789e6394059861", + "d91c100854f48dc365af2edc0964733dde4cbed88a4922a63840d42bedfea5b8", + "46e69dd777810b0e24e9f11681079c8b6d0078ddfd07f2e4f9f6e68d0e02a9d4", + "8e8523c5b8c5824dd2bb23f76c807a7e50f45306eb935876ef9044248614bd88", + "6b5ab9bde67967b20e728d9e077170f57304ab134cd018b146951a4c270fed2e", + "88cb8c6910dbfa9bbdcf58a96427eaafe55032a855f467f7fb728f7d08a2ef1b", + "5bf125288e9aa62db1c5a95f56ce517d7586f513980126edc6bd0c1b9f4d73b3", + "d36f6779418e723c6c6d01a202aa1e0acb51398b3e8ea0b49979128154dd9778", + "3a97f923eb707fe378c0fff18c926f52684e911cfa1f4701a50d0161cb06ec9b", + "ece19a6e1d4258b27121a94196ff5e050e6f99cccf113a98db067df632e46e4b", + "5651fba6d3e1208ce54a3cc26e6ee044cd9fa3a303813d1e26fbc31ecf8315a4", + "46cf4369bf51dc148565a5940876ebd12ccbe05f29db51e1b2be6b862d13dad0", + "80bc19a2c8de91bcd662762c867e9588194f2f2aaf6013dc17013b88814fbe70", + "161bf78111ed14e069e194b2555bb91ebfdd6461bd975af959f4c337a1c95a87", + "21bc2d66f0ff51f2a9c07abbee3ed9ad6874c0fbc7144a7d1493e7962cd27682", + "fb4123cd06994876f37750fd9df4493e731de71bd537666efbfe532de608bef7", + "6fe4b0a5256ebb9d8872ae6a08e2fa0d822ed29ffd9e326130264593a48758d6", + "b77c8121c912ebded966ded25d54724d1bf37f49c5ecd8e965fa62da5fd17fd7", + "d4545ad0ec7bcb5b7ce0915aea5a1ff4831360aef3e462887968802ec65f318f", + "d36c4907ff019cbebc33597eb78c99e23bc085fa1f00ad4c6b603ae434335817", + "11aaeaa8fcf4f548683266bc415868603bcd35f17519b14aad55b5c4468dbc6c", + "5eb368c786bfad55b8fbc19b84fe3b5bba73fb86e8df689d37d8d767caaa0d4e", + "c2954cae05d08989dee15b7cd2782660b0b0840960d9fbccee013ae29df2e80b", + "49376b645220593b252350ca3c38e02b72e91901eae6c38ef9bc724c942fafc6", + "5680080c312cd825a60440d8dc550e4f6df9f01e750df2e65742af675dd4dc39", + "21c05cd6224fd242758f784507197aad044e2a05c8230633c9b83826a5decbda", + "8c0cca556e5b11ba3577d6bf03768a042d4174121074c3a908d806e883c2a3cb", + "3f7c1234c8e471e64a8c3d917a08ccefaa8e30889979d971b9eb31fb0ec15a57", + "ad5a3a82f2aec53a5b49626df77647bc472828ba22d9b955395a5956900066b4", + "5509837904cdcf4a33660b9f20f5adc1bfab049fa4ba876dae6344fd1c3ad2d6", + "5e64079f20fe9963f2d434a3b87b2f8b660a9cadb873a74a09cfd66f5481d90a", + "36e5e25b4bbe8f657be9105b010a6b614908880e9ad02f030d68661e7e9b4d19", + "bd2ff5eb86e9516b09f3630108896c8a1b885959c10061a215988f27bd133b6b", + "16f43c14d2338c946812ffaeb39009b103af55079a888e0f359579cf201687b4", + "4a02b40996b05ca77f6014b9ea3252ee6239f0099e46e53ab00e9b6c88e68774", + "aa7f4a48a1dcfd3047e94771eacf1477917193480f2c7ba0c319ea4231866f20", + "e2ceb64edffcdad59e6318fb0dee735778459f394c7a20e7d49a2d4de07aba24", + "e4a9cca821a218193777af92e9d53701eebd7f54aff6d20ca1cdaadbfd2e46aa", + "4224bde85389bd9d55b838587c40173e082d12510e67ab03b89732bd65e1da20", + "f085f030e2c3a9c456ccb81ace063fa2772c9d5848432d3d01ebe579bd8391d3", + "46d41311a2a57f0f7f6090e99762d8a3cdb94b64dc939e9e43025d823a8ca601", + "9a3bdb82706dfad47e4917e963a907fbb7795242d5a936089f9c2260fe01d78e", + "ce98d0cfd8379fe3838279c222b498484993d1484c45a369abbfa022b3da7288", + "f13ebd54aa52168a755f787cbf8c65d94263900b17758a140b66b33cb82d3ffd", + "363399ed6c52ec5c34f225014e8bf1e01a38ea8f3a95feef7f9eceaeea5d360f", + "0f2fe6a57d441969eae84ad2aab5ce39416a359c653f5d7cd8a9b0e791cb1648", + "6735e7ac54112238096c22aa234987c00f2d7d74c6aab221f99f9e8407d4191a", + "a29999f1a44e195f1d072317318dc13db25f07a58eb85c2fe2f092948953c3d1", + "432ab0e372c432a56ef7512fbc33cd54fbd13922f922de0791419c9d4099f2d9", + "584c138cd7b5990e66508053b0b4ac6142f209fa0a1e378d285f94fc81104092", + "5c1c4f852b1f5d00f47ce79cadf83244ee3b1cc30407827e92823184f512f824", + "ad873dca7e4591f1e7c60cd93c4b197b03cb58c4693dbc4e01eb4c98cd0d35b8", + "b6789e7e720442c0bfd46f0c71d1dda80347163e1697b4cce3d4ba42eda411ff", + "9a82521a80d360b889a9087dddbb04acadfd3950f87bc35cf98c914aa32d7836", + "25c49d87eccc3c7491b23f0b3a3848054a5d5335e05cd2e92716ddd295689695", + "43c3891722610bf7dcaf2309e45746952453f8ed577883f97771190926116394", + "dda458ffdc2a7eededd7b77b91de7286b2d9af23d05c14b410e027c48be22fb6", + "d4ae3b206ffd10eaa165f3b1ac3473de20677633bcf5d2b619b35e94931f4495", + "7b5baede60790e429ec00813ae1a9d2f879b0f724924d687586e5c7971a2942a", + "b24e5ed56159cfd7ccda8afea479c4ab1c872722930aa3ce47ad3414b3f307ef", + "ca41a582791483a9e5b2a564ec3c6cc07cb6ac9101a38280e76cdb549b48c99d", + "8a95d5aa7533f3cb2e3b18a3113770f1c4021ffd3c7e0d34eff2a09f846d4b39", + "739430c9aafbe3b297722162c980919b33f4b87ace72fa3a0fc914192528e7b9", + "29e49794dbc14886846cd58a8dd1b4c0435513dcaf0fee57a62322d0614dd1b1", + "a7100fb4718c0e91af3395d984eaa4d07d679fa1d6eddca09d190ec4e20c5e74", + "b43b33f962b93b670fbe96d20cafb2bf00bd504ebe5c57471365f129e0ca36f6", + "112a3a115a157405966debd13cce047e9354659ec6c1e044638225f1f7b51605", + "619008218ab1f6386b2a033ba607bf30da5406cc8f4ee4c34694104ab079ac76", + "17f6649d89e8e72912c6319c1aeeaabf1fdb048e4dc99ebe3578c85e7fe1211d", + "33145d1ff5845e1d1bb2a2f2a9fa11522c6fd7160e68fbc90748286db13a0c0e", + "35612f5b5ac9d7181d9deda10ffccf3a9cc2ae7661c10d4e45d3940e1b1033ee", + "f29880c8f1b7df605cd8ce88a964ec161a953d1d31419199fcd3f557670ff71e", + "331b3f16024275a03bff3e809e9d6b9e474dd1bef0bc400093ccbc4cd980bc29", + "4e9aee1ad1b9e76d320c183523cf4704adf5866310a478122f2190d3bcdd4b20", + "2c1552e1a9ac626ebc10a90c281125c8b2121c39ee4841d2b5f3d90ce1da1ae0", + "49acabf0ae6d97b8dde81f8d0c6474908ffaa2268130533b46555c5a5a12d95d", + "844adf2cee6438032b27f8f9f18215514e43c3789251bc90bf8c8c4d620310bd", + "5370fdfc43bb761de434677b88d8334fb14f96c220501546b3b5ab540a2e8b19", + "65c632175a7a787d00b81df163bcbefadac0f5f0cc66b145c62671be3f6cda4a", + "6d33c9f86727240f45b73adbfbc88fb13ded3f944a945840b04db9ca08d8862e", + "c1c5ed579c20f4661f6f4d1e30e0562c43a0a2a21c6a89c963aef32b933fd342", + "76a62702de61b6dee04400b30525648f6636b6ada435097deb68888a404941b6", + "024c27fa3827314578447f812920b4f4ce60c446bfcc234877b8aa7712c518e5", + "0f885df8d5386ebb88f513d77b9e9832d923ef61a64f8c1f95db6e10e3b66f3d", + "db2467f6aa334840b0c4eb89c0bcb982d771d73414397800aeeae4c103536f62", + "d59029d264a77d63cc5bd739a339ad55e139efa4277deb11a9897107402ac8bc", + "4d3a83bee1d3fb74640808fe6ceb3665479f8db1ebdacb0116991b10198af85c", + "0ad417f76f19c7c32f11edd7df872ef1ed4fe48a3890304105c9e37937237eac", + "8067039f3152a96c04621bcb58d9cf31b386f7152b84bf5658653df182f5979e", + "1a2e2b0c026b4ab88b7cde85ebcc7ac4a1014bb0c9447e258fed7dc36835e26f", + "61749914e621488b293b386911ad29493d5dd8ee32b6d81d0a436d4915e44974", + "adf51a4da26ba924ab1d8335737a0cce6551594c1a42170e5f7214c25028f360", + "5310e7806daa13a4d520f0ef68830c3575c939a67f9457df936965c6632416ca", + "1e7fbdeb95a54cab77e8bccc1140825671df223fb7b7068b05410c7cb3b4bb93", + "04a210521dc23e6222d8ce290b29af17e208cb2536830c66b91e507f0aca0a20", + "d92f2181cf3e7a1a9b4a79f7934f06444acab413f2a237b0462562c79b144395", + "1f0238428f8e693ec13b054201fe7e5ab9fbe56664303ed24a230ae7f152982d", + "39996ca0fdf74eae74e20ce127e94013719845553ec365a6ef2777ed9921d12f", + "96099895102654b46871114a2563589a817126908a4e076b00a734ba917c7e70", + "38139766fb4f268c4e53131765ab7a1f52c47f2a5526109c1f211bb1c7bd3fa5", + "065d3e90fd920cb5ed569627c6df3a46acf07cf953d6d0c37d6ad11f41cb648f", + "151f5839993d64284c6105cd31e7aa859406ad55222b3373ecf467ceb4f05b06", + "6ae4d67232e8903aa041955cf51409c2784971ffc5914a6dba5d9c06369eb2dc", + "aaf2bcef2d83c374900219812336b1a1b0467a7a0a43982a7402e6723486e3c9", + "346dddf2dcc883c25411fcbd2239bd279d35483f98f2747c82251be6952f006c", + "0d435a92fdd281348d353c18d02fc4a2c0a158d6601a07ba544af2075cfcd1ef", + "3a55da476665995ba58211513a3c5d85bc1ce5809af0d9e2654e06724d201956", + "f85e24ab68b6cf7a023caa109d29ec149be374de6c3e3a4efc6977b6d198f396", + "ed3e0f7c902b8452d5b5db74f027134e24cc1bba1b98c42e267fb057db95ef5a", + "dc2102e715f1b7f0ab96743a1442bef3347858aff1d445daa048c2fa2d8f5ec9", + "6fdf7cba8fe8da2ee7491f074b8ccb813f9479b7939755a5dc04677da8987468", + "73c21201bfd7b66ecccc0a6cb0e0605d52567a764de28d0e78c65277a38a371c", + "40568febf08d00771f076c0c5591d4887625b961fe8ac748247f962c6648a6cf", + "060fa3aad1260fafc724de036a60f7775757991d5d3d74201329f895de9363a3", + "289c0d763d3daf675b164f7afba4dfedc6e82c0f4771447fc3cd8bd8d3db8560", + "7762a7e19fb6f1bda7c2fc1774aa324ca5d2920b633432974576ac1eb9321893", + "23c4a3e242b04dda8ddfcb823a43e8cc8db5e3062fdcfb5b6e59772efd0d898d", + "79483f67c73a0aa603a5f651bc0108d066123fb4445dfb08254ce3b422a0683e", + "085f6902d9dea812b671fd043886a8def7e5babf7aee1557531d3c002a4ec5f1", + "7391e7480d1251ee0d71da65aa20f4bd0cbb5c5a724a9a32fbacbb76b1e6ef58", + "b4831bfb6eec21138daeb74784c6ced7b8a5937091d28d0e2b257192ef12796e", + "486b9783f0f7f86eb1aa75417d0e0ea3d00ce6b1418c7aa92c28fdaebd9053fb", + "c9dc39b3761161f1f6952e38fa903b5e526d845e3bc1151b283ee5c1638b38df", + "e14a243a4be058b06117b058f2975422cc5f007068eab4ff08f125bd6c70e9de", + "e001cd329cd53f3bb0cc1ae01fe6e8af8a5dba1400e4b4dbeddfc723dfc1bcb4", + "9ad4888dfcfe7ef4a7fe15a279925c0a6bbd9b13d838663d0325007bbd1e1186", + "39bfdf86c0853502c745592cd23bc86bba31ec9d28b07b2c245bbae9e95f5bd8", + "77194d637117fe17aed395c541889de9e2ba3f797db3f1d4d3455a15068f83a8", + "cb7909a46fbf61bd1fbf0fd13bdaaf103526d6df2fc1e77c9ec6f22766251a44", + "ea5cf2a10103ab5a7f9d27f6cec7e1b1bd6a115afd747b5d52ca4b8cc852b038", + "7063d69a3267f46b285b9fc774323f6cde934f90de454652f2b059f310dee526", + "9570fb7d4a45f0acaee1d85ae48c1afe33b0a093a489646c5c9cd8b03760c4db", + "5f140a61dcc085d109714bf742b291204872797bef759f11885c98ea96a67f56", + "792a4344ce23891d9f7cb111c18b08037b388e4611dbd69581bb6e55c0c15e62", + "67ddb64523fc4989a514a4420e82a5517a9fe69f93ae598dba375306fdafee79", + "32712730148139c1c66232f3c0652fba2f7d5e11bef920905b00784b49677946", + "fbdda40e37df9f8cf295243f2503c285ace98b09d78ec8025fe8062ba216fd8b", + "b671a78c80833d9253af13ea85f85bddd25c7332708d4d4efb18d2c3cfba1cd6", + "bb4482238a7fb8685450207f4d0d978a41428b06d0e048bfef207d092d54ba0f", + "a8c357e7bc3acc984f8a6c9e3f8fe1a8919c8f5e063d2b9ecae26ec1b4f536d7", + "2c6be05ef0731869c8ae74229a9c8a13f266d6cb84664d653b366a35f87eacd2", + "fa23a98ff2979455f251b5657c91873dba5bb06f2ba37d31c130c2b618a98b61", + "2f737a3ccaa4c514b557d911e65f5a725bfa028e2636c6b013a00c5dfbd35066", + "928249b3e58841791d12a28afe845da9bad60c0830c3495cdfdfac5a6f9b03fb", + "73f0cfbae24517945df5e6889c9d4b05eb90df833bed9d7b6b5c7f4a5b3f2f20", + "47c4d28984bc4d44f333b04d5ca5fd97c74064bb79c1ffb79f3ba7d7e511a940", + "d40df980b355b762914b452c874bd1ef9c52bb3df7d77862c1614dd32b394d30", + "29aeec6659342d809691cd69ff4d9bc8cd0342454270672cbbbcf3720879c1fe", + "62dac10031d9e9ec1bff4238f03948f9ec72599470aef6ce414b8633d7fb3baa", + "75e404b815c3e989255fde9a2ada2fb74e29525f43f4704df4146b0d41f160df", + "ad7d18c6453e8bf5b9a754741b2a56a3a5f2257c5e7e86f8153d50b92c697a5e", + "4813dbff737fe53f04e1b7ac135309e02b4c5d46a07ef026a5581545c019f971", + "726b1f508442ab9873abde380debdf56f620ab05e088ba31d6f3ceee828a36af", + "ac3f97b1921a6642616bb3706a88a121683b82ff09c88b8b83755afde8404a21", + "2bb05c88ee72cef3de0a7c950789a3b4b04c52aca90c1b2b3096830bfa0a7439", + "ff2c47d9dcc6bc3d0bdf18f26f34f64d17947229fd8cb0730920c4e5e9dffd4a", + "dd009a08d95932405c84556df226d87668d3ec9986e7f65d5f2666fbbd075b2f", + "9cd158fa2bf599da05b9025ae1604f833820cbd8177769f130e6c549728a2582", + "fabe7f39d9890f3d945db8c8e1f787db76cfd9b4cbdfcbb796e5a1f9c601a0af", + "cbd4d955659017ba5d199cdc4640f3c8345262f577ba49b9c0455ecab1a65cdf", + "fff7bb6e6f45d94d9ac39bf3a2e10df0f00c7c84af664bd695dc91319a0c82de", + "2568beb5b65ff016e1d71370aaf8242398d4ef4d7dd208b1c99f0adca604f211", + "99c9ad4768f5e51a8ec0519b6ced63315d0f9e0f2f5ef2eb605ad0bb054a85f2", + "794a573e13e8013eb755f9e5e6c5a4671c283b59d87fa4cfe53ad713389186d2", + "cb4ef3e3662ad2fa9f46d2e766329387b86f5a5663227c1981726f4f2304fc66", + "9e5f52713acce5ad528b4472db00342761884eb40306211a9f406aca5e9a0d4c", + "dbf718927114feb8f52ade2fb0ac783618fac692ea71f77b735099240b0d9c55", + "2217b4a2a8016a1a9e459ee9e2c8834bfa73215a9497ca1c588018e328233c00", + "7238098748b0aa289c389e3d5ab5c3569d0b2a3f3a525d2720d6c7d05509dfa9", + "d06ffa21f97a1a36417aee030149377c572ba1211e034653854d9d369b3a5f0a", + "48487a2b8705a37985a77f6f514fc3d45004a391e578b019bf19b7ba700a16f4", + "2ddaacf08ea48b9d7e85bb33e50c82843b9d88ae17079f43bf4d7fc3cfbbf828", + "f1c7e4a6835585ae7552ae33dd0389bd0731dc1ede703400c285afd5d3aadb0d", + "6201726f46639ec1926fde3c0cac71b879327bc2be8993d846802e60afa90116", + "9c6220250462a07155e06486230852a55dd134221435b0933778ea8d14e69547", + "52107388117d91bd94bd9b9af02722491c0f499ebafe7f5433d5dc72022f552d", + "2491393b063c241044b31c8ddb42b0b9e694ff63cd01c6f4cd8abe665e4a34c7", + "a1f9cc9a2d756ebbb0c55537eca5452346ab80c902b2423d8d040a0a04f70ed3", + "b245ac0ade1b66e11aaa92e81f9cffd44f757cef6e98e87d1747ecd088c9fdfe", + "322221b8d53452f5a9c84f09ce60d85719dd555ff7c5028706684ac066272557", + "fd7a91c83de883c55736799afc1860fdcf3c1068d1717af8b76b3862538e2f41", + "5ba1170f36e428f3d0ce389bd894cd5639241021b79c9eabbdcd9346b56ef680", + "82e5f22efa0d6bd0807c3ef9e7c80ba9b99450c5dc053b8ff03941b2c2cabc74", + "90cce0fd208106f9002dd05f3bc976f1e1501643a7b5814c2306418a9a0eea1f", + "51ce252eb1b8acbe0b8211764245dce26924e0b1ec21a5bf88886dc771ad1e11", + "107ae846370d12307c294551debf9ac673264617443a6e85cff045dc8a030ef5", + "98630f4ca3e53d2a0b78f59532451ced9ceff5391141957f6c124f47be0e18f8", + "82e8e429e3940b6a05258736fc125406b81bf8b389202ccaa6087ccfdd6e69ea", + "0612a2b7903c03eb07320a734fbb5bb8aa7715a6a3180548063fbe295940546a", + "ce17f1c7a762c88fb85ae86377f0b4762dd134a44aab16075e18fb12775a5301", + "cebe9f317719eecd5ea06b787a2f8654d31f2a7dbab28ebd077e55c58c0f8eea", + "a8af5f008733854f9d843d5f16a257b8c7a9796eab3d6c48ebe63cc363b5efcf", + "4b605e02a5637ba5752a03d19b9fb73bcef3a14a574324a22603a4c95b176a89", + "7d1f906d5e9f3dcdcbc72e563fec9f2f678616e38cca0003456e883d2d5ba586", + "a1f5de8504db2adb9e82113901e46078979b1021d8e604b5139aa890b14f17f6", + "7e7a0a9808e0404c22291b94f0f2a040dcf33feb2798ec6802a844c7f97297b9", + "4bb1165ebb0612d2608c9078a6b62a1d060122e6321e4e542efc0cf032e8d6b0", + "f7675960c56f78599501e6152b6ba727ce4b93c15567c9a4b367f88357555f93", + "9a0e865eceddf932461af97bf91e5b032ba8bb27d2229c4e7cb2a39fceccaed4", + "638c9a7727c6f189edabd86dba63c0394be9846fcd66fa1e744f2604265bb182", + "9e6ffc4d621b7a14383e4c6cf3819572bcaa8ab4e2f22a0fe66190963ac9ae9e", + "af93816cd4c0b5bea6e09829f0669a045d49f106026cd56215fbf8144ca95f28", + "e1cf3c8d39771156c5b8b1fff44fe921d021e57fd8892c7454e23c1153908219", + "8753cd7ae1aa62950edb302645a5106c70aa9beaeddfb211e814edb0aa55db88", + "a369d422d0ebdae68bdcbacdacf67c31243d8a3c05b7c84f610bd384ccb53a50", + "0b4d389143220e239911c2873c054e43183844b52e345449c8bd1c57d56c5bb5", + "09a5c90989585ece2a98a9d1769494ec585cc775f2ba9cf694b7f55f61333eb4", + "128275c56eda8b4bffae1a3751f2db4194a60d64b2f574c7fe5546b1248bf1d7", + "a92bc32d1fd757bdae9871cc78eb892d6a878ba1ceffbaea7921691fd1093cf7", + "db3a53276c63c7d001664f0692cecbb18f3ca284f011c45e14d04c63d78d2bf5", + "3c9c7da14bc8ea9c4f4717e62488ad3b1b585ee627d5ef4d5af9fccad632b1d2", + "98f989b582dd598c59b8f6c1b95536939926fe300b06ead9c002abd30a447a8b", + "f4e9af9921a2f014d552f5f77d78ad2a4b9ccd35ba45d630ef7296f04acb440a", + "e6c26024a633b3ae43a374bcbbceae7dab533d4c26ef30518e13fee562091948", + "c8227b877110655ec557e4a1ee583380b12fccb5e5168aed6aa6c3caec6e9fab", + "2b052cc979677cd68f5ea067ba0b227d7919fd72c64f72b68a35fe1beda3952b", + "cc2e20ccefc28a639c2305464d374fa99023e7b3f9cf1649c9387a36e626b761", + "54b7eec4495b6e98bf7e4f9ba7119aefe68e01832382e914eb6d630a9520a5b7", + "760e7b8cbc6663986cc3f2fbb0400a88a792a69044f879e4727e5b46e5f826d6", + "754b3ad000e135a1356050ac3b314fcfa265fb2b37cb04bc81ba268e264c5e9e", + "da85aedc68fa98a830b72d5a6b75b6563b7a776ba26d57061cdd000e8e806cb3", + "5ceb246c490ccedc3f2e68d1cf23019a95ac93609ff74dfc08bc4dab8ff4c0e3", + "8e19e4183bee9dd18e473745b4565f9fdc660abdf08767e7440ca0617d78f2fe", + "2220faae83bea930cd0ac548fcb08a73fd3c781e91811632988e82921bf5cfbd", + "c57e28ad78d428ea3b0c0eb0971397707c2ad6eced2016d1dc3de91c0dda59b6", + "f41b6cacdccdfdbeb6001960446607c8d51500e2041ba798c3db6d03c9d375d5", + "4c0dd9fc52190cd046687eb230ebfcb8df9108f66dd103d27afc907647b32cb0", + "1e5de86064ecf4b047164a14ff8b10fb6aba68dd321c84a39b823791ee524adb", + "b7e43dd3cf1f6a94480c8838613a5434ebf0087de138e120d35490abd567c6eb", + "dbe859e4a5810f16302b4abf140c79a7c0e6f5bea7e527c79b3079203d3bb7b3", + "102f1494cd09874ac41e20293e4f25b680fea66f9a404bccf791262715b054db", + "7966a156c9c0e210dc516a1e8089efda68fdd35932a40912de5cb05b0c702def", + "32f6fd7985ac21e34e2348b58bb7179af184d6af2742384878cdae4b26cfe33d", + "c81abc524408164d1a54752c4e49f2f04e09baa2001df3a204fc3e4565c60ecf", + "50955ebd311d12a7568a1eba98be01b3e87f2c82be2c6ff3acf482b08e2f0532", + "bb8152ee0e03a7f56d3857326eb8196ba0873ff8bc27ccf0329cc876311ea290", + "9fe3c67c7d05b6a9807e7dc398b3e49d8383f74260aa3e00239481b69870f78a", + "254b39495fd1d8e8a880742f46dad283bdfdf9627f95a7a5b6ea741468529e46", + "09c7d5644057afa8454dbc87ebb8c2bd3881e942f07f0f0041ae2752cef1870d", + "854e6856fde2e69feb3d4a18158ea178937cc4f34dce75d330bfffd11cfab230", + "bd6c53747a9fbc66f42f28d25dbc2e69263d80bba44f05977bb8b07c8a285dc1", + "a940de9c40c7a13dc7b82aa44ba1893bbfc24d3bbe1d3f8d824870a26bbfc812", + "cdc68eac23cb57038a3d536c0c4defaa18ea4c2c275e9c9db6be4b95b2d98ea6", + "44e4dd07fd34832adbab24780d12ce0950380c12bc148c585345cae1204665c6", + "a067619bfa22ae8cd56894c5f914350be36cda4ab95afd8ff526b472a5f005fb", + "59b301e09a6a78616e57c1ec3b1702d74b7149e99b57a97632b41e844bf0351b", + "8b2124e1b1c8f14d2ff066afe76d9f3264fb908c9257a51b2d951fc700d4e0cd", + "d346f85d2df65c91d9b7dc934b1b93463c9d54aecd00447d1af354b65fdd3362", + "e8339f595efc1f568d399b48ea182f12022b117266afbfb6a219002f21eb13eb", + "81ef6fe8e30e406c4436a7056452c7bc27fe835719e039d26c9772c1ee90941a", + "b62c3ff17de4347c973230bd2e7f884c3011e64cb92d125054f79fde32bcd108", + "7ffab5626a565e6e4df4047013d43d743c0045b73ef71fccdc60ec6dc61de6f2", + "38265cd14ca5dbe1d7a0c4e33f16dced690b32cd409890e4ee174d3786b91e5c", + "d38993b563160879ff6c5c1d4386f8a42bc9e4cf98e0616c61c0e7e8841f1567", + "86b4de48ef7c6324d7d62d235dce65a3ac39e253c5c7c0f6156e7b7dad6c9eeb", + "c55c3e8746cd1d0c08d60354c7804503b685441848ebcbf5e1d527d59ad75241", + "af77acb965efdbe3ab709169f9f4d4ddd59b0414941e53a467db4310818e0f66", + "4ce88a04c5642d1045e15d3699b0660c2e59f75469d5903f3e816664aa3fb5a3", + "8eb05e10934ce5bd4f44aaeae637adb9d8099b698e87511b0c4e77e61bfd648c", + "69a21ebd9b0394b549a4b14779b58465830cf73eb5fb05d2d7ff136f6e845d65", + "8f409e794825cd6759a87cdb03887de38c32860a68cb2a2d94212da997949781", + "edb0d70b59596f1f89f3f4141e29190de75c55b54603453379c30ac73c3fd990", + "286a86c12d795c7aed46810bf1ab9bdc9e6e3aff393393efcbeb35102a78e4ea", + "ef8aba816c519f8bfa4b263754771e14ce2b51ebf85e8bf00d8718d76c0b803a", + "8c167bd5ddab53ab345703a14d5eaf0209d474d19a5e219edee8cb0790ccf0af", + "ed4423dd263846a796f12f7071c99315a96140908412e2442503b9ce9cf3e484", + "997c491e92575a601e5c99e3322b8d11955e09c1ee72534bcc7d8328ebe34343", + "c497f419c7ec7b0c63096fe4f2d93e82127044aa7df4d1ecc2978ac18d570c20", + "5100edd48d43fd051c19faa3c77d188a1638ad4512c42c7519b8b86e38a9fc8c", + "6e26b182069e4c13f105c04b1661f39807c955a70850a3f97166691549d81060", + "d3686b0799725e6364cdd046e7b1bb26d6a76161ca35312bbf4cacf4413b0e6f", + "8ca2cf2c62118fa6398e3cb6711e08752b355b475bfc1cba0f54e3689681cddc", + "a37a7705194704c9d66956537c387c6700acaef6171145d54716c4380b45a7bc", + "65938067da03d16a9e526863012c386473870f47df08be850d93d8d089fec624", + "ee4fc010addfb4a39dcaa2a43bc6e44c9cdbdafdd910239a8220cd6461b89ddf", + "1f1f9bc124562cf370f52a062d0110a58ea0f2ecef63f11eaceee17176d463f3", + "0e4f857cf6629bf13656412f02046628de621233f01593c5b7ec72a0ffa51cce", + "087b8161905af7ea42e9356660d316bdab4cf828d06834f410239a951c51d03b", + "6c353ec907541347b75a98195d8f64d7c09a71d1de9fcc4d66f447220df217f3", + "9e55522c9d2fd1ae118f484fc88f448cd192d573546906322c69458e18e94852", + "3dec2b7853ceafd6852e2d57119101313f3e8b7a613bf88418e0beb7a36e66a0", + "da3aea6ec7bd6b6ae22d3942ea71cce3655d87a1981da2d1c23a89956501d41a", + "9abdae9b171be8e541d0f079a30f0379cb8dfa7d57c0759c5d52c85cdc810822", + "36305de3413f7641c3f28eb79b6fee60cb8cde4960026174a37d09e0ce9a814e", + "05244d005f619cc5d136b47ef1efb34dd3e1e0f00d5826d7460e251644fe2469", + "d46b6b981bec4c979fbac3eb8b9d88779942e3d4081d731700bee0b69e4a720a", + "388c4bbb4aebecfb8547066ae636aed2cbdc954bcab3ec2e86d75f5ae30b9cdc", + "e8978279119ff02507222d9f709aea0954e2cc621eb85d58eca96b97c3286f9e", + "c3f51c1ffeb8ae3dcdd8555efb4302955fd814e3e8056fae0efd8d0a4e8eca34", + "f1e3d07d3c26a985e192c4e743cca769a8107b758a14a56e59cfd4907d6bab14", + "c43dece890a24d95326bd0a0ebce5a6dff6d83a361c485fb3e624265ad82720c", + "56dfe4092e4d059f18e12d546d71568214618a315810cadcac4b012e3b78ca06", + "c16917cd00989aa601c8b4c93d8aadfd8c58df3e72d77ea8cf4629f8d18810d6", + "8bea07af8615eec05c7c1e551688f8ce1813693619f196f635e9e74c00d4043b", + "f7185e4e717d3fc0e62a98218079a28e39e56a8d5231a5162790c70e6655112d", + "8edab2289c5e50c5ca6f9928cbf0850ef530c3f3e2b4f1aca79e9d4d91efc305", + "5065a6ba97b5bae018e075a88f9ae27d9303c4885f9d76f4795e96f6dfb5671c", + "20b87aad06573488fbac4f5da021832a8b90036604c4c703a881bc0f681f31bb", + "9ed7ade6b2026e21c3fc219a76733cf6291115a81ab359805250ad44add183c8", + "9d78db73de83019e8db6ef5d4b400a6d9a473c99bf11d25ba90f6c0ac49f34ab", + "f7f7a488c1e0419ad499ab8197c7e00f00ccb84ad11c06ee6085c31bf5735670", + "60fcfd934fc53f9c4597077708c9c8976b2739b19f658cf63e2d623d4b041cc7", + "250e4787ae11bc83b5f78da948e14595ca345f4a8c028d07529f4ad477f68e9c", + "b7478c83699d7e8cbc05e170567bf877351eced9c961a94ce26b782f63fedc31", + "66b200e6691433d2fdbdf776a3d1e971b0dc571893befb0af29b2c0d81dc9ce1", + "a3d85507e4e251494654f5b8a410c7f92729b8e1e4436a73caaf926e5d0dc175", + "d2b4984725e468c57967f603f3b00225f5dbaa9f8e221aba02129640e5df76d4", + "7081c47f6de0f2eaeb7ab3eb040fb6e0734e515dff31fc3670988db1e37bef4a", + "1bf9d9b8ab9689515d2fb603d9c24ab8a0a8f4af98b07228fc521273edc514d7", + "a6f48d1dce952111f5acbbe368492ce35985be1f8ee4dbd71ed9b47f28fa8829", + "76c06a187135d39a0cfa4f10e670aeaa6aa962a5bf44f7a09552b9525bb567ef", + "b44a51d9ebb568d1c07ecabf19fe637860337f83b7bcc2ed6988bc5ef1d1a1af", + "f1cf961e47cfa57d0cd0a61dd3e51a50723dd0f476990f1479d04fb38fcef02a", + "f6e2ef9160aefa44f0af915cdd79b23ba3a61c493c56826cea05776216157b69", + "efb90bcb135b482f19b988c747ed5047734a6308f9b979446f42f9eebd670042", + "bd008dea28e069af6c5798cb04ae18ce036240ec8ea0da51c94034b6f5e97c37", + "fef1bcd07fe5388498a43be6797365f3e4e281d180eae495367b9e00743ce1a2", + "98f3b4647799439e918b564617f15e9b353de26d0a547f0cf89423ed8aa8fae8", + "c2ee0eab3bdbb47039933a6fe0cdc550a5629ab1519b8779eda3ea02527a9b8b", + "83ab8860429d57b759c8e3119fbb2941c0ceeeea578f324b798d247be4fc1802", + "621c980b5a2014703d37fee5d1f9c992464d28b941ddae37f379d6cb34f10d55", + "391c020dbeb2ee1026559764cd1f400ea725588cf9b0164b459dee7603e948bd", + "c837ad9554dafe5fde40a1f169809765ce54f575b23a5ba7c5cecf83bc6f166b", + "9ad1a13e88f265e0796644edea48820ef87664db7bd27254581bb5c5c1291c5e", + "3c6b4ecf36d82923a923e19bb0161ba8139e177a512039284e370537018ac363", + "9ca21926397fd2c1a496f1c4ab4ad53ba95c88d59c9c7ec90554b56072153128", + "574bef7df9ceb959e3e3c9686fe32a4dabf8d52b1356561ac30d12e4a0c48bf2", + "4d206ea0b3f2602e5e3f68710f1ebc088ce77e3d62635af2d943494163bf5b4c", + "7dcf2fd5bad4198db733f3dbc9f2bf81d3e14db114d7d09b7bd6d8f91e90266d", + "0da5adba28a8de2b93a16685f2d8c28ccf052da078fff19e932dfe4a4792c0d6", + "8625ec665cfb2c3eeba97f823e36bc8cd14d34009fcfdaa16e91d4e9e060c266", + "c675d63629f5f2f0ea04853fa9ae14c6fa6fd2e715cb01f2393edb27263add1a", + "bf2184c0473415dd708975f7f1085b2c4fe2db889246da212ee1f94abca62c7e", + "7a7e9a39ad829a6b1dfa07e145d6ef79661e49279e1632cdb5e4e6bf341ebb98", + "95e971a00e383cdd4f4c8d142751859daf5ec25487ef9e05280fa59c050afc3f", + "009182e230b91f042d34b100943eea346605c86c5387e206d74b80e9a6548600", + "5dc2ca5fa5407258a57838ad46b94424862102a238c7e6630de424496ae58bf2", + "85e3f48cf133c1edbc42129ca4b9defc118598bcc938d407f7b8ebdbb09d2335", + "1a0a6fb7030c2bacd4dc41500a16ea2e04dba65452ff98dddcc35bab118ff81d", + "0c2ad50e5ae18d0fe25b221d4d8f14bdc15a3af5505ce392d7640f4b1bca2022", + "557a988a31a5b9d8d30b7960a3aacde587a54d175571e1e0afeb38068bb15520", + "9f53101d5f2e16e79c17ce846283752dada25733ffc4b6558ddb0d2a1a1f3164", + "e763f1ab5c795056f1f59041ac996db2a43a9af8a79f5e07af6878b5f1f2cf0e", + "dc3e6041b0b2ea9a2ebfe0b549f83ec7d971149efb0f99e18d9d36fa0569be01", + "b3f860e37881608f2cbbb2d76d016fa9bc921735d803415bf92620571840c891", + "31b60b45803113ea8e7309de8974830d1817c10a6c37030cdb8ff78a04ec00a4", + "e8597af0b9eeaf29c5029aa7dc81df6c6933027cc002dfbf885ed7a6c460f9b4", + "231a115db48548c5999962316b9464fca1069b20b5866e901447725bc03437e5", + "020b7c44092d45e747961fd0d33fef372d14c1faf70f2d1779d3d62d2945c2f2", + "95b7ccc2b16bb3a31acf4fc37b98fe2bb266bae1a6747a9c859280c0db4ef7b8", + "a3bfa701d183c64c8f560b2bd33b20c3b50f70a9a2c42cd65a3c8f6d92979b62", + "39be52e7e41a029b5a2b266b482513ab016c272b5e7c4e988992dd492705e67b", + "390b8a8c851746f0978629eaa953417c80a3001dfc758343d26440e6ee20490f", + "df755a9aaad54c7fb60acd391b7dba36b595ada46062344ac49cb4548c78a883", + "c8bf4f871617cabdda7cdbd5767c475225e2349727b07a9b319645ec171ae561", + "fa4a01119e4d95b46e456f8674bf7c11013c9a1fe105d517face2cf1fa76587e", + "e7c00d78a831ed6b2849ffaced85db9374e18e49e1cf30da8338fca8f52262d3", + "e2b4d8574b153756bfd71079e15878e08095849c0637efad1344e72aab5e3771", + "2f6139475708dbce0ff852a844ba9da318a990ce5618293baaceb0b38eb4af6b", + "967eccd40d779934916ee2cd34dcd6328f7454bf25d511bf67efa56a0b30902e", + "c92561fb49f73981ec49d3374fab2ecf952f4cc9e3579ee0cf09a9376f5cdd06", + "1562a6caf6418ec58e1269ac558ee3233c25f93a9f0a1d2bfe2d4875133fd282", + "7ab24dd482d63141442fcb5bddf2ffa6f850cca962b5f8da56c0d9dcef25b042", + "206226da9e87902126f725be503d62145d8c8ef0d3396acc836523eefe36e3a1", + "e1e206b758785bd85a65133b207fa131a1319419c06673f7dc852b1f21cd59eb", + "8931710c5698598a5cd7e6b2e3194264c886aff27fb101cb98936baa05f15564", + "9e6bd09e3aa9c77353b9ed59e4a439adc312b94ebced34da5bc0164cdba915ae", + "3f6e6b96a5a43e7628697e46988debbbd9b947c1d284b3d814a1519cd9e655d1", + "ac86bbc8586f6e91f46cb6cf95324d16c0b727f182784bb249cd26cd12efb47f", + "e3e1dcb1824d651db77f0add253aef2c6d7320ef89fffc0f73ae041572ded1f0", + "a96214f9c8af36c73f74d6e828728baa4e4abb8b9b7e3b501cc5336b478f61f4", + "a616c58ec9776869766ddfca4a18cf38bc371452edd08f191b5685d6e5f8e319", + "b8935c487a7c2911bc29ee63534e42a55c96a0178599bb99d26a402238d85c80", + "c6c8aa1ee0fdab9a9f5bad142130b6458fdeb630c9fddd710b74166ac0988f73", + "e628e02af1bdb36a5282ec5220e5d1dcfe224781477207d49aea417e219bc93a", + "c81794f47f7cc5804a4c00f00e190a2df7b61d792193730a174d55a7745c3276", + "aef8b55359c23b5bb804a7b04f1adb6836c9637579dde60301ed1ee3236996ea", + "4435fd0813fd02ba7c1bee77e31e64c2c3375bd2e8cbc40f7f14c078f7bfaee6", + "357758bd244b0f011f531736bd3dcc812db81198717b24d518fd80cd142612c4", + "bf32b3d85bb7457912812e3022a91eeaf16c68e4e861615c2f6d00215348aa7a", + "b2c93d46c894c6820f9b9144f8748e6da2590a90cd12f197d5c7db723c14cc17", + "a733111666dc03af6a2e83eb9a0ffbe2b33bc5346c43c88311d3767559ca15ba", + "c7b242f598ad67d839eb842d5dd02d4cdd117aec8c84742b8a2b36d830dc4f34", + "7cd412994502c960ce3c41f05b7cc5bbe078a300b69a193c06c28f0adbb3df43", + "ca57a2357420f8f520fcd3586ca18a886c55bd81445fa31e98caf8df310aebd7", + "5c392aa077797f7edb84874bb27337b3872bbe7e130ae879b2591ff8346c0f96", + "cbd684244936ed0cd09c5927e9eaaabd57862596ea6f9cff592bb9766be3a6ce", + "4174dd88435cf48e3038f0ede2127b0c5d0416aac2ed02fa71c88a2a0b568482", + "79d95b4cb551b841c88f16259f08e3f74c980cce9815ead46898a594c7191b97", + "dd96df260871f266676afb7f9f63674bdbd8e75be5a748dc16bfb7c752d8033b", + "9ded7e1145f61ed7da98a1d519f11e7eb33e8b84c819e39eb49c9ee73665d89d", + "6b6bddefc09383f008d6797cb2a9fe365af649a7a287e1b0990db042fb96f33e", + "7257699f76956c709f728b52b18e7a2b4b31f33757a6a8a1d4c9b4da40bac512", + "9eadc24cb612922f6a2a2749c533f88f03251b223646c6e553bf41b65ac0b2fb", + "f30243f46da8900e73cbff23abda6dd7778cc8464a586e15504cc50237bc8c6a", + "9ab3ff711bd0017b2e2a5580b83e784cdc2b26ed2e8a5494fc643e65fdd5af24", + "76b0c75bd023bdf8c41c99b2ed2910876671e18f7ad05bbe9abf7b6525ca7c18", + "535d1ee76e788d5b1448a90f21317033e4a5da9670919d99110cfa150a3552df", + "e04a7a775e4cd506813886ed45917ace5525dc72db8c974f54c7c92b830870e0", + "9de6b4e8c5f572460fe972e8330f5e713c37571c34db7c728f64b7117dda756c", + "46007700465071c9a113ef3dd6d1a164e8f4e954bd1e89f1753818ea15df4cc3", + "bcdc8e43aa3708369293218cc442b78b94c684bf06445db8f3f29695d998cba5", + "86bc7090cd02a1cac29d8e801d48776ed7a538f4eeec33b05841013d68065cfe", + "0ebf96326f4add2b5b3c4519e3d4828fd8a849b1118aabc08b92511ace768a4b", + "b8af5cd546c7936d4bacbb02b045e2433cdf259c33ada99de3119912b5856a80", + "958f3ca1deec9201f4d002d31ea8f229a8997b2e874d075bc2060ced078f55f0", + "d9306bb9f62bbea514e4df7c1230ff30bb886fa940796c8c214585f22808512f", + "dd443bfa55a59ccfa873ab91be72c10699be4459d8f2a51cc26da840839267e9", + "072963351fb540393f9d5b0100574bc1c577d6872cdede1742e8c4b438e615a4", + "fdd4239bacc29cde79fb0446675e1138eb74a620bc74acd20882ac4e71cd1959", + "d344d1f3b70a91242d30c551550f0d47994a74cbda0057c0847972d0ac72b98f", + "30fcdc0e9f6015328a41d24feae533ddb195e47af56b4de85f45fbe540994f60", + "44459262682b9065855505932d60e9c5d21ba514e20d808eefe3875feb5dfd4c", + "b1df09c2b22ad9c1754bb17d7389aca816d7d38eef5821ce955cf690f5bfc8c8", + "81b7da4b6beb9e97499cd86206ddfdd94b1a302739aadafa6ba83a186e3ef2b1", + "5a34dffe70ecfd882098cba7c542cd2d8dffd7057471e7d3381e6da8c05c7d00", + "947b627bcccd1fdaef6fa635c4ac906e55bc7ddfd190c61ab27c7258d520710c", + "302423a943a70ba2f1251ad938d0f27ebc28d7d87896ad5db55631fbcb87ae78", + "3dd22a39c0d916498178434986b5daea6eaca2136c649d84c38edbe34a519c5a", + "184b5777cf166a9f4970d3170e88a14b9855c477b326041a5ad9387695b3934e", + "9c957529526c545d8a2c7422e0cfb9ed8720914fb9c2b590ae3a778774471bfd", + "8113cf0a1d28590cddc9910b772f3b5c5cc622ec82441a80c04ba379c561f33d", + "90207686da47ff03dc13fa6f69f29efacabf69aae9d815b6bca9d31432d0a0e1", + "9bb15bfb406fb4e550bbd712a83a5d78c284177a0005d7876eeb6a0861601977", + "a8c2e5217bad0fc0e385deb3337eebda37f74ad7829414e2c5194f0a61c0ef33", + "348fdc39f1ccef382758844e8428789f8cb4628aa9ef2e89559bce728a2c43ae", + "23634a41b2e6c1e4a9e658acc0e6cf6963bf35c8e1f96085546d8b799b4df774", + "2be2e1d2fa54a96a5fa2fa2b2731327fa52539c089256f6da458101266dab5e4", + "5099f3c79f8a9205072b261baef8a5b5a6dca37f76e32ba083f25249d448082f", + "8e24bc53dd40549cdcc536445fbd6f39f9a5394c7a1c4d2116c05230a4dc04b0", + "4b992f45e8e5b0ada6ae9e05d1d13a3932c1a0688c2ccbdd1b249bb67f0ba35d", + "d55d2b5535b913ec9ad25064ede622dfc57d3c40e947b0247de29cc4b21ff349", + "de4b9445cf350828ed23f1a26e6bfa2e460021cc07388a35dff51157c9f0403b", + "1fbb09b7a876efd544b3244c3fda55cb99d2582d57b857b887a8916de262c693", + "1357be1bde89a16d7c19f580fcb88e70e3d6cf5838f60fab480fec4f7255dfdf", + "796abff22a991020b97218846140e0e25bcd3c0f64b242ff3b45048a23dfe70d", + "d94d5af25e35b2d25835164f8701a59ed56e63cebe0c0b642ce1cd315acff6ee", + "d531f86254de8a1733284f0ab19caa7ba15f900dc5ba7f0c9176b1ebc6b1ef91", + "dc6c68b9c70fa0446c01b80ceb7a219e3257eca71ae7c1eaa0725547736fd5a3", + "94ff806b174eac6f6260f43b947f7d73b45aecdef6a15423bfcce78991690193", + "e1b7226edd6d6475e8154f757b9b02c45750443518f38736986642d4d91bc2d7", + "9c05ecd4465421e226b9daf61a94ea7c5bcae2ecaedabe7e30177581d119faf0", + "6578060bd4e2484deaf3a213cacb31318da712ae140463189adab0be857e4a67", + "fcf1fe1a4a05d7c015919be0e5c3586ff2f5888c5e9ee3078cbd62b78e5db986", + "8ee945b6415efee0683e3b7a55b91f83fbccacf9e1ad5237f6fd3d36343f8ed3", + "f5779afc4f1aed280aecc2645ead30a3fa6262f234c8a073ca213d825369fbe3", + "028a567398beada065908b79f8a92799ac7eb667bee484fb0bf570d8a4b8243e", + "92cb8fb26ee43018042085cb98d710dc9db8cabe980bc3ddff340093e0638b4f", + "d379267f92e2ee67ab251b392a58b221136430da6299e6385be60661e28d824e", + "fc00bc8b850b2b60caf9e12291b0e446421eaec492712563cb8eb78a7980dc2d", + "d15fd1e595e1ab26e5ebd4fb55b58b4b712c39e54d7885ece2bf011869939763", + "4a7c2441db726572980c73e870a422cfe88a90f0d3b0ba9cca6a4a7b283d6da6", + "f9746ba7d2bf958bea8662512b1d032e7cf6d9c84a91732db98024d0d5cd5983", + "b266d772a3146d14ae731d34f23d8056bd8e95a4ef04ecd56549585c624076ac", + "90b535c5d772539b7a41dc7aa194b103c132ff5a53c25e905936f4d79f8e0b15", + "ac8736c9d3f94f65dbf96915a0b34f57a823472dc01b8fcf1aa09db90730e502", + "b038985877feda57211a188a7abc555fa457d70025c668c3b5eae0b900077503", + "57fe14ee0d9aae1cffad9e5ee4e60f3f69afa16745faf57328cf1a1d3534bc6b", + "05bebfec88f4949854a75a8d5ac0c99f820b075a37da9852524e5a52fe84f445", + "388cb3ae86b0fae054dfc67feec98ce98cae52db00f4567b3e4706f5daa27472", + "7d850934aeb39eb1683828d1dc09f536e42917216daa12c9c29c0140c083e871", + "c096fe483acac794b4ef5b204163f4750b6b9aa84d3f3ed05c63d50769ce2b8c", + "f3c23e9423ab342a6fe2a0b6e53d6af335e56a50cc917987e5a11c0e850145ce", + "c02326ea5956f04030c89c92c5eb679b2fa4c6acc1c0b3617ea20cc898a81d53", + "feb53936f5d21c3bc077b7c1e36ee814571cc7ca20c406fdda15f377d7bf7d3d", + "bdc5e5f1afc610f315855fb62644e057fd57db083ab42f37b8943a90e4017634", + "94a8dfa239ab31aa3f4f810161ff2b30a4e294fa842f4b38d48c7ac2a0f1b024", + "3b7771942bf0b91a424f44f8dd16dd0772ad270707f131eef675a3de1c9a8fa8", + "2b528d4718c52562d6fd998e3e44d732a8d1026a42aed965a156dbc5fdab59aa", + "57e2b6cd77aca0e04acc2c6741d390ea37fa28b302ae386d0a494b4aa5afcc75", + "81a1698ac10aeec418961e6730744b633febcf0404bf37194a4ba601bed164f3", + "d8ff3907d4e5ab88588a5ce1d1521bc0b026a14616b9fc3c22ec02b64f0df258", + "3194d36c217042033ab3d0e8ce56c296b50e50cd9a76d99903da9a1e70ed935d", + "2f71f8893fe1106c48c28ab6f2b07404bafccb968edf04757099f6313c3f2606", + "a8367e2642ee39c74b073718a8a58b9b9a46ef66692ebb9d8a3d6c3092786a06", + "b1f9b6e0a73f44e98c64e557f3c49301a9272c64d8448e8c654890e03f6eabe7", + "1eaafc67c5d5533a398912419ed2a80df95bdf748eef8e62118ff5c518d0ea5d", + "1720e088dc29f001227fb5ce768f93381f14cc0b037cfa875bcfea8b60edeb62", + "37501af040d573fec19c67dccca82447071c8069f4a5809c15787d8cf77824b1", + "839ba8117c2f491fcf905ae0577a9ff0c0305470ccd045e94f8cd58e88b24f47", + "267e039c628e181819ffb09d97b054693b1b02c36c879c4c5857eb12792f5d47", + "01cd507dbb589810e6dbf305134fd58d87180f1242386b71fb2c714587efc7ee", + "cdd29833cc4f11f897e1b6b74699a8dc86139d115811a71049599ad55283c847", + "4d9c60abd7d4007e923c2b2151fb1f704a414fd2a0dbc30c21e38ce06d73b3cc", + "2391a2ef33b8c805321477ca839c7ed7ef7398853be7d3a27f3f36ca8dc9a2cf", + "e992c895d68760dba75ce1bc415240c2d16c89c1ac4328c033274ae90bbbe75f", + "75d263825359bf0629133c0acf8b6d8d93d534978beae11dc0dc632e665d9cba", + "3d4d17d44ff626315e98d141a662c6b5cc4c8f525916a7b4612d116ada848650", + "944203a0b58ae14ff9c084bd4a0a394abac01fc28f5accdacec912363e3848ad", + "efd8e4e7e1e5e682c03ee2415ec6643beb10cc081956efc6b22bd1e1132c2b85", + "7a40ce773e0f96c33569640b5caccc1a109c1e3eb274b8d93ab20dff10eaf350", + "a6fc44ef8ac2af8ffb04bcf8acdf3d1062eeab61cdf3d4fda7ecd16688106627", + "d9846564ed348a273a9715141207b46b6ac10aad9854783e95f6a6e68648c4b9", + "5d5c0914259d0374f935bda3e1dc485f9e93e94798aafc1ee1a7170ab129a46c", + "fc75bdeea665bf8ba862c18b9166697a25af7d5d43ffa2c486458fa7e5892f6c", + "ca19f9e3c0068036060c680c4413b4034d418f565c6131939d29e7e640df0fb7", + "749966116655ed6d6627c0a8f43e69715a71521c484300006a6bd54f430550ae", + "7f239760ceb835c08f159b316abaae62a8ef04c17df9de994c495189706f71de", + "ab3aacd4ffce6f9ab8adea7d14ac06afb229519d747f4a29f52f492a8c64d46b", + "760904d4239e2096cc70dff39555879f22a5abf03a43ea15c7b2adf279652045", + "fc0b557814f979de978856014d1f3f14ae383a84ba56d15ee13891c158a5277d", + "7c8dc109fe55d484defa434673378ca3dc2ee76fb2055ef2873c4a04de985c37", + "b2acd8ec458be8928a4f72b7bc7fe7d1e65b5e1a92b61da77f1677ba2c0401d3", + "1077f1948925fd8785e9eb76e726104ddec0ad3215b31a4bd09cfb65a0a179b1", + "0f143aa07133cf19f3a78eaac213a69a973711255b2d14dbdf85e214c2ac2d01", + "6b12e2b47bbdcc3d5d8e44f224668baa821fe5c8c13df77d62e509f69a823f22", + "d2593ac51d6e7604a1269f729c05fbdb1073f48b05fd6d9b1fb61a50102f2037", + "a21f0869f4d9f042230bc322f4e6f778c72d9c4ef6df8f046c4e9af6b4519c59", + "c7f9fbd75e8f9289321234a2d7234c02b1cf02ba7703a34dcdf2ecc3c500058b", + "1e643ea8d50503f2096b614f05dcf25ad8fdb207d2d5edf9371fd2467baaeae2", + "f899f52380ebcf089153aed1568ece5f227397230fda9d5e2288d970db4e8900", + "bf10c15a4f02893789ea69b01daa254ffa30ba6cff6b8c6b6308b2b6c0e98690", + "721ff0bb74b2e5b3a1a59ce843b1259a5df99ab8ab1fc1e58ccad0b91050ed33", + "b0186abba771f60bece237d9fe1b8336cf533140f6421db1432507bb70151870", + "d62c8b2ac8d8febf4cab2b2e7e17a29e5f338b292f0a80168ece0bae898dc52e", + "bda8b5c2f2fd5e2aec1bf01142b68c8647c71ee796ba4343a771634588ca7c59", + "c416bbe5d84275c7a5bb892c1c29a483d07a3ab66bbd6f697997b1c5bd04bd1f", + "36a9e45cff6d4f0da668a615242c70bffe0daf25ad79ce237c95a661e70fbc77", + "c7017da0526a26d693de22e05557a534896982c3a5315d54582d3c50dc046860", + "d3c13c47f8f148545e01418d1f2ee2ef733a013c4453975ac407d6569b4e3295", + "ee647e0207c406f2bbfde093583b71b293a5772325bd64b33e4b74f66b7da340", + "b75b5df13f4341e1c70bf1aba2e739feb588e47bfe3664b3b2666138194b974c", + "46b0e33b14cb33ccd8425c13c83495a4a916865f6ab28fddbc8477e74ca7af1b", + "3a72387ffabc64319121fd6bf82fc292635a83d295ae0a86b0065e3a68b45cac", + "90471fec85a6b1c74a215189c40739e54cc70773e13d955cc6a96b22d3cc8b95", + "276ca8cfc4907cfaab90b4e19128a212122baa5f7ae6269808274318f29d6d62", + "68fcb2c82852fbfbb15575c03de4c8680174525edebb6a43077bd9af03e86826", + "fe44d9ca49b9ab941a135315e62159c9da0d07dad57016f4e08c042dd9b9ef8b", + "0135dce1acffe7f8d615bfa08d0a44c6bd7b3ba636d2c1b38d1bd89e8e870373", + "43c1b312eb844a794a19b34e290e8544a843c4f3338a5a48938406962d8c82bf", + "31e3f38d32ec42a81d87ca6c528c78bec644c4d07f54c1da9b720efed997dd40", + "a56c51d81b49f8ebdfa54f5f721a660d70f4ada5e6e2af822c4bc0bf98db5954", + "1b7994a76c776128c3075be74b033fd40d48b14f59aef66247fac1d276831931", + "589a0a56b277648f41c5e12b30fc7b989e4284c28af61949818e782781500614", + "d00ced5ed36cc62453c75a36d8bfcf0aadc23783e1b4453aecf0496a57b6751e", + "9866ec2bff774580c10a3b5de2ad9f72b4329c64cd5f99ef20e67eb99e0c9b22", + "a0458d454b60015b223edb7d4f0e69b1c021340e14e061b8f7b894d48dfc2a58", + "7edf38013100383a5e1b0f64bc75838a33267cf5a7d04e341680a1782f098585", + "26e0b5c89ba085320d53dea7138c9fee1a2d00eeadee3f3a4ce3e1a906bf838c", + "108b6551c896350805959032ca7fbea219346ee051a2e1f63883029050f8fae9", + "7eaa34889e8111de968d312cc81768766610a1dc26d38878a66ac1c3a425a18e", + "70cea918f98dc791a78d0f15d0674e2c794e214313fc2216d99ee0cfb3851628", + "4892d3c563530328b8481c2acf6c4265feaccaa1d5b2bfb1b9ca2b142d6bf36a", + "433932961f5ea9eef583ac44adb3b2148c8c410da001d0b11fd7a244b8c81680", + "f24d80f10342cedf86f51412554792c2bb048969f5608386a281aefafae485e1", + "05a7ca3458ddcefe16d9d5ae673c018d2c431fb687f9c7f61edb0b85df0bb874", + "ef70f2fb79761d227112c12915c91d8bc646f00fed29b5928db07876531ed321", + "d898cf1c6270d1c46c87ba44546742dd53ebcb1c5de8e961ca7121e5ae994643", + "dad70c6063a51fafb068ad697ebb866d652ce0b2b87f924749040fbded97936f", + "1b86f6845b96b09ac51e96354a6ac607853f5f8900d40364c4d09452718aa453", + "df9fc12db4929cd320f62ab7647193369ccc959262304554b34ec8680dddb1bf", + "a12673a91e5827d39b255b5e5e4870ae4184d30ed58253b15d5141e1b494d798", + "df08b85646ca485cc846c32722f0f3f98c4503ba3012bac41740636bd283a848", + "5747c326f5573a6b983c93b28de779e8c745f752820e1a1ea48ce66705948394", + "0605630f9db28de035dc8b3074ac128835157b3bce0c9197e0a3158835ee9aaf", + "37cc4f891a76586692b94b6b5d29edfb480ce686e1af44a409712fccfd426ce3", + "2f57fe8fd80620fa7e242cb094811c5d095aa05b7ac60e317cc8a7f191547479", + "aa4b2470f193326eb0f025be4a67875125782581379edca5a0aca7bcb51ea693", + "6d7ca9696468a66388f1183293f094198485ff911e01700834fd9ebb82998260", + "45c3d85699857642a9f2b64697977c62fa4c13bd355f8022ef56ac23803cfef7", + "6321a95fb15bc281f56dfa46baa48de819850c1aaaaf0f76b7aa8436861f0406", + "5d922f09ca06338a8b25e825d822138b0e48ed90abde8613170f485712a0eaa7", + "9af0b9fcdbbd1c767afbba61a60801eba47cee7780202f89a9c9b41cf9356685", + "91aa14affa7d54151e3bdb8c3b37309f08f341f063e57f9cd069459af07392f5", + "1ef0c749e627ed37cc23750aafcc3d781abe3414b63a1d8e544e51ebf7dfbcbd", + "f34ba9b83f4fc8a06b038081778bc70f0074c4a3bb6b827411e137ccff5ec400", + "96eed92e667cabad4718306a2cbf4095b0b1ffba14bf449b3d636096cb421cad", + "3af41940d591c0faa81cc7f5e0c0ba1438285fbfa899211ba701d41f6fa8f848", + "3e95c78000f8f2403e21d7a6ec52361ad5d70f12b0996d553c7e0a321d01cd95", + "af0c2fd58e16e67657ad3a417ab0359b4f39d7c5becdca039aba99d3d6fc269b", + "288c3bb314b4327fd7a56c4d82fba4d9400c868e453bd49f0a90b2b81ea84256", + "3b204f68c6efa9cbc902778bf910ed50c480bb8af54fc3c3d30e4c7a6609bb24", + "b9a3cccd006c42767b8ab2d5c06761a768ca8d2d2a31942eeb4bcc7d472c071c", + "7983f3cbd60252cc46ad9ad55b858e3e2c08f9facca20793c2c40c1de6c5f7f1", + "0894d3e14723a63e0334bd54bb8ff842e5143eeb691ba6c726cb1f13595352de", + "0196bc10427a36b28b98502cedd311a1e39ace7c8c0933a33b9ad03d3c897458", + "11b18df65128bb47428c3fbcfbab581e1f31ee2b76631af336504670feb1752e", + "12c94c4498090f976a6570d022095046b76bc82820a29efc3366d97595c2c90c", + "f254b8e825c037ba90a90cf511f0b271362a02a6b8dc270b9203aa0c3dff016d", + "c8368ceb6f0a30d7210e791061af49615c5bc2a18879670f603e92cae457c0f1", + "ea69a2e620b73728fb89054be3b2da472877e93acc79fc4ef87952b2728f0270", + "45e0c57ac9025eb18751ebe865d764aa211829e49e753875ddfe62d122dcad5a", + "f806e0b7d151c910b04f1987b457fe7c0031ee4c3bd7a816f4e6542c67ee6bd6", + "e68588337b0cb511325a71f03707d21c4fd1f2f207ef6607b6ce78cad334f28e", + "a13324ee8f43b7ac8d93d2e3b835306b9ceda77206eb3c45972e42a650c4153d", + "a5aa5d2192fc5952987a34ae83c976630b7863541a2416d057ea1869dc2dbad7", + "0561c60f74567e6029ead771ef0e93655493f0921c9fbd7b3aa37cc1add2cd13", + "bce4a92519d16a7453449f385c79e93ed929b542034189f95baed1fa63870bcd", + "bde91e5aa7948344f15f76d2e8914744b1c5c0300de7fbd137eec82f33668c70", + "0f87c9dffe0a56353916cdcc4b8ed88825e63740b26bd6323a2563ffc16466ad", + "b3b2a58ef185d4999ac2f81d3a41eae6ca2786e71115dfaf44019b545ba15f93", + "e5b95605f17b1d4136f618acb789b7dc25d663a74f53742854ad0df6f21f15c2", + "bfc27bb5b801db5235f96e6ee4845b6871090ed092e4c002cbb8dfdc0c90666d", + "571dca9678d77791f29cd2971ee5d4f7e50cc06cd4869752a523ad3f3f673535", + "925a055c2fffe807af1994d17a6fa36c4bdaf883a6f1a1465da82cf3e0773ef8", + "05af698fc837a31e6908e02cbffdbc7e1924b4ebcdaf0c252f916eb18640aec6", + "d8196b52a2f6b8dd8891abf0993df1e9a9cdcfc0526551790f7321c3b0863d96", + "e986a779e8218a9c4d35a2450210a90ef1332201e3c6f1dea6ce036ba2e0ead8", + "20a75cc268fb97e3b4fe230d4a9325b7503c1bca43d3429708ce1a7d91c8f629", + "337fe30992e300df733a766078d10644866d08aa55b6df6772d3b39657d14b11", + "595f2077535c0595c06b87c17ad34aebf079d7c17014eadcca0c32886eac4175", + "c19137b426d65ce56a0bb47f82bddc787fc2703980a49836ab1ad5538af524d2", + "75b61fd2a8415327ba6136485fc852e2388a6035987e06bb90daaeec41c71a9a", + "52c0f77d629847e0633ea0d4e2005d12ecbb8d71ea466908bb59fe59c5b44091", + "565a29c5b97ef6e38ddd823939b44c8cac6e950bd965d95650b2ab0c8ae6123b", + "a13f0bd4accdb0432a04e65c517bd59ab0cd43be97dac090a334d35cd5feca96", + "4235daf215ff77d101ed3a9be921c51df685dd756276bf4f57fe8f009985deb2", + "b145842e194effdddb7ae018d596fda348dce28d7fed96758f6de9edfe6e7ed7", + "b680fe2ff08bdb7ba90b5f9c085ebb88fb597c3f6e0f92e90aa58f48e4f8411c", + "fe8696ebf29080929cc720afb22d64ed9f3d853825eb1a13e8ccfa97f4262833", + "bf58b8cae7c9bb22da99e494fa6003cd041cf1b2c52b299431da58a19ba3cb5e", + "ecc595019a1da55754e8577d78b8b9bfa085dde195ae1a78a0dd2b6ff0dac2b4", + "2b054d04cfb6164275813e075c3e2edd20c070049b55901dc8f3d49c9ee6e0de", + "9c1f252e0a75480f71d9c91d71daad01dc1a8c8e9333b761cdbb62786f0ea5e3", + "0f748e88387f65a4e41a81f27f4992b37ef0b1b06974379118fb2b7356a6dbef", + "a570e9860b323400ab735b87e31ae4ee2b35c241829f4f705c9332818a927869", + "1b401734d2ffc349bfe022f7b8b17b8712052f76ae3e1752d82c34da8d833a08", + "9f32a7907be4e2bce8b92821d620b61555a3263af1d084177d9cf72a1b69663b", + "9afaaaec524dc14468046c99868d9ec72d251ba20eaf4970f0a8eb1dbac74868", + "6b4a9c8334193d275fc8be3dd7558efa7e6a902100afa00aac70b8ac67d2bbf6", + "a1c10e713c180192bf534a6e38d62226b32dc1a671ce21cee5979f7e4775fd4d", + "2d8e6f071bea40975e7a92020dc8ea83a9f1ded3d27a1bc9d27e92ad8f471aba", + "18d57a462ae1801c3fb7e5188e0d03c2c59dbbc28a5ef9c8a8e1e7d1fc35e15f", + "09a41373bd641a981e51c1f9c14065ef9bf8afaffd3491696067ba7daed1ca27", + "5a70d9b398b83332bbcbfc88356dbb2fb8b9f3c8472b1bdd0b4134ffa375f846", + "9eab03689265057ae1ec1e24a9964978489780e73ec67740a1cc5d46ef6b5a96", + "ec031faec092367ee33462c454d9e9023bbcc9302f24350db62d25f595410837", + "c7c2ae9253a810b7cf2da14510277e19dd25a8212b6338c2de70f4a341a67d44", + "abf26f84807c495e22e3b74888558cb0dd9abf33ab5b4c0dd6654ac6c68f24e8", + "f2f3f5f28793dfbcf2bd39963a901816aca2df9032cc048414021e4c4a9ba956", + "1f4f94b054a9e28a7d6737a49171e23d3c8508dd4ab81af950bce7042c63d650", + "10b2d89b2641c929e24b66623cb60970a07ed3730e20d62f15bfa103620d1d6b", + "02c6e2faa01ef52ea977b2b39cfeb314164ea1a12fb0e3b8f413939552baf97f", + "b8d09f6d8a7bbf9bd0471c125ad7c0b7cef603598c6bdf4daa7bc767bcffc53d", + "cf35ac5524851dbbad8c26dab40b1d350048fa5d723d74e119cf4c5f42a01718", + "e5ea33cd59e051c1ffe43ce61895f78db6dc25a5744038e5f4df39d2fd1e244e", + "68d7bc9a31030a8291685c6dd12e774fc9923ad4614cd1f5b3c6ca1ca838008c", + "8ad68c834c7446f2a3cdf55f1567d3f090b91bdf2c87319d3fe8f070c3a57af4", + "c193c17a1bf6b4900c5da3fb36aa0e6cc08e238f0b8e5e6c21f8ab40803968c3", + "03790ee7ba443362a42b7a28bd4c61d6501a4aabc6a6c1ff3b62034011c2d978", + "d7515f870460e61c956a18db6c4db8b5cb6fe0d95fb267fe5f3d06a02480e24c", + "954f2d04195129f064a4be3b78ce079453f6bd5f0497bfb6f9a7c43a9adc38eb", + "42308ea999b0373b2f7dc1eebb8fcab2f2f75cc158395550aa8cbde321264f7f", + "a64beab31d31e11f196ac34b9aebe274cd362f2c7879b9f273e3a11b51d7566c", + "58996bfee2f56c2a813a037e3b59041848cadeeb9a92c4c0cb7dc0add57aa8bf", + "4d9302e687bf212c6f30305e4d92b82d0814c44013062adc16a9fdd4f3e21cc6", + "af257bec2b2c78ebc75babdff99f75d1d9df89ab7e5f530fd0542c82fd7f773e", + "1676eb19909b55814b4921f51350c465c3dbe46eab4e19420e7d82a5644b402b", + "4e0cfe7e16a1360583f04c210d9f78b61b146461fd62e6c4122cf3f866dcd955", + "2f9aaa76411b1ba45d38f01192a88d7c600f122c7d716745eab0091190c70436", + "d5cc67ad12d6fc3c8138cf3a5eaab7aed7566f6e71392f9ab10f8bd56d202579", + "b60d1bcf81fbf56adced62be5f5a805d675f3329ee36f9a7a1693265844ab415", + "80988eeb0bccea171d7dff2ebd2a172d727a26e62d10e30438f30781bbe03719", + "dad61920747e00b28308133b7f6bc123887a1f97c0961ba4c5a50ce0334647ae", + "8ba7a36a601cd57c1c149aa0958cceed930a5bdf05c127a7f8249bf16a274f4e", + "fca5b527842bead62042d45f0559320b69472162e63dae8b8b13f70dda189adc", + "1acf315812ba9fc21a58086ad247b0a89fa66d14e8562d5d8254151d905b178d", + "535448b85e0cde6e5e81d732b2663268a1f6bb5c757346bbc818af56051affff", + "03632641c59b3eb66ded213569af9270c222056a18d9f2f1e7fbb3e5ef3c0af9", + "e75308bc0d14f7462a04e08377411ee8e3f317464b08d40544b026ea5e82ed64", + "44303978f78ec183a7e06f28954b978fcad06ffea991e8dc8be59d9c70582198", + "038905a6ea1484fc50ec30e8c586d74d2529c8dd1c9f335d3f93e724de6bfbbb", + "ee1c89c1daba52bd96e95d69832e7f91e347fb5f34f34a42c5cb8d6363ca83b1", + "a26ad7362ba577c603c8f2a9a37dacbece7c85a0bf57ef6781fd47e35186c1f8", + "99de944f1fd86cc5f03b849ba680133f07d054e40b2fd249a3c4013d10d76aeb", + "7ea01880def2ef9cecf60c4ac0283abd9abed611e13ad7094a60996b97f26212", + "26e40f6dad42132968f512aadcb1effbc948c4b994ba21fab75965ba8c4c0570", + "97b4dbb5d66a95af6db43b70fb3050fb03bf71d3aa5d21472000229cc9068beb", + "01b760cc47a2e6bf8b00b3265b2c442fbed6c83a219c6f60e58bec8343948663", + "cf784e360a349cab5246fda54f3cbd11b7d0049698a62156872b9fe9459d495e", + "6edee969b6bac2ac384463de11ad1cb0d343566b0dda7afb518f6eb92553e3bf", + "1f38cdc076c5fa9a18d6fbb2f2c733f8a5ba8d762f408b3744233cd3aced9075", + "20f6bde0e0435dc6f15365269894fc087424c2743dcb1e9a3d65ad4dc46c9115", + "ce7d3aa8ed045b18bfc5729bdcf670cab6109f76462d7afe88f8a970e61f93c9", + "204ede6bb52dcfba9c22730c050af96add70fd48c3e3010263f3f6a20a28f0bc", + "48cc7fb1dc4649daa30efba9e682090724177e9f9549bb764c5514337f3d268d", + "24314566ae35a12ea52f0ecb4695f59845f253de083ff711497b9b101b6c1215", + "e9a66eedcda29591abba585beb911a440a6d6a21ddc2e5e234a3a0356f058e12", + "a0cfc9950b3b61dec410ce7eedcc16b491172ee194668ac41191922d34113bb1", + "71ec747aef87b025a002b5f3b2c3760ee7f5076035f19d9edabaa45d1d19cfd1", + "79f1e6e368e7eec4a5e829a5689beac2eafb630019af1001451817201b608f91", + "a8965e1bc1aca9dced34dfe1bd6a088f1dc5d81d7c7ffc97f2b32cc80fb561ed", + "964e3df98462f4a103c60ad5bcec8686f7d699755ccbedc1de9a9f64cca8c703", + "889fac97c5e74bdf83e7baef14e2aef819492ed87d69309fe8fc97bdba627240", + "39c3ea184d22faf658feb1ca734d351eb5b63a735ac7908a90e6c67ae663bae2", + "86fb8ba122b171cd6a1b629060ae71a575a7d9e336e989687567358207843b53", + "80108b8ae87ee47429c7aff77f4b4f3b14fdd9f692e49446edfcce9d4dd8654d", + "d95e671ebbf1e638e287049dcf877c502f9208ef24dc1490f78bf76a9075c3a8", + "9ffc2350d1f592ffd1b178a78fb5f921e1fef20fcca76d3b670ceeca5681323b", + "fe9a5fb81d00aec7b584318c9b73889ed5c7542a2784d2e8aa6f3d5bee240e16", + "08d54812762ef2762698ef50550a6e56d4917dd016dec078048c807a84604e06", + "992bd5c2017460cf61fdec3e7df2f0fe97d802f781d8c358893733249ee14c26", + "9e8a62eee855758e38e380ddf272549ad8e1161a535c5aae218a52223262c256", + "216197fd43f6b7ab6064d6f45880e311fa8a312110bd571f9efc0a86b61d4d9e", + "ef6f55f64c5e640a9def6fb02cfe63306adf3828fcbdeb0a3dda02722026a5b1", + "7a3d97a8d1175c19d40c178e73e6076a3a1163225ab6edf492425ab0fc9316b8", + "5d34916813e3654e7141b1018743ff6c407992a3bc04ca18f3bfd4ea10c109ab", + "c28aaa39bd0268c0323bf931f4309db93e89297bdf699785fa8a9a89f535d7cc", + "b754cfb5e1201c17b43b905adb7139a234d721a33a78b41e3b1e272799f90d75", + "7ba63dd5539547d7e6eb10ae6017a6790bea0c637aa676b5f36df0e33c79fe6a", + "3af2b6e228526d07da5370243c6d2cdd19cae0d2808bb70dfebcfc8ece1c11b1", + "fc3271006ce71738cdeb62420df2ce021e86fcb1a0d62610bd23c042d6442f54", + "d203895ca7309b7cef211cb3ea3c74e058a622c6f998153421bc72739180a614", + "2e8a5c6580bfd1e42e3e4adb3ce21db385e00d8b1562b5498e4f2faf12a27961", + "ddf61053d9cbef7b2466fc4a279d6d1a158ff6929baa78582e46ae890d2f7bdb", + "dc13b1c067ad337ad6a9b6be93d683e73de69552d785ee4df090c70f6e434d8a", + "5b51b095ac2832f85c71fb744a39bf010af7bc144eeeeffac8f22f2f8c0e6d46", + "96b4e6a65122131102e7af6ac9a9566e9aa6a62e826b7a0116ad13216360c4df", + "7b28da39fdb19a58cdc06f88ee5544291f34da7c05fa0373498c7ffe20785a90", + "ee77c0717163ff975feab287f1daa0f4fa11bd12e1599de564ad4efbce17d234", + "bbc2102bf69702527b579e70a29c4778ef98db82d36cd77b38026bce8fbcce76", + "84e71144856fbf9146e7bad4256af5ccfdd01b598e43602972d1a660636b6f19", + "b4b4bd135a8b1a6020ba4aa8d94f71fc7a6ecb54711472e2314d79e9da96e573", + "972da6063cf391e4059972722ea3ee8095e414a8425bbd67fc5b8c5616ab3a92", + "61694fc764c8c7151f1d4c1cded4b00b45174ab29d0133954ebfd2297d98062b", + "6c8b4cec9879f67354298dbcbd1f2ea241681b805e298c472eecf817becc434f", + "0f2495f4971b5e924b300cb323317c1e318a03fc929d8b72a851d578c685e0bd", + "43cca3af843614e81b82cb534996a3380f56504e5847eb094d18769070fe0f29", + "f65283a9351d86b9008258bd61c6fa5b880f17c44430431dac03464ba4c2afff", + "ca06647bac4db9f6528a06761a7a2df5506a13986dca57c82c863427ce913640", + "36c867b2bf979d6778d5fb1e3087187da3f779f30a4dffdaf5c83e45b367df2b", + "4ab8b85120fc63bc521610d8312e5938bd402991f9d8f2e02f31b2c4d9da02ec", + "b67f53f1d15f99ff678696696923bb3dbcd66c84e82517f29a472d87935cc6aa", + "e42cbed0b024bdf26163db927dc8dce3f14c7316fd8f9cc0735c6fac6158e159", + "c85998262cc9690de9e4a7ffdc02612754988b488b2d3dce567dddb50a871043", + "00ad01e897116d2710ef9b69b78e7ab6babd26099de7e577900c42444ad66c0f", + "919d76336a98e96b704f4ec6c6a9f1aca9572158c976745b441a7bf4d3423928", + "bc46a84cb43f62478eb4ac3368b75a03a2274b2a03cd5743ce57fe4a959a9b2b", + "e4ced3036e02955c70fdc96566612de32f186be3206eeb1d9e3f97c8b340e1c3", + "0225840b83a061c2cce9dc9a3e9ef1ab1783d6e17e35d16999b06d0581639b31", + "ff1731ff6e964f3dc825b4b481063f4e7b7f4b2fbfd610e0a1a2228f0f5462bc", + "437be65502bda13abaf097dabbb5bacf0c48b5eb5f6460826caa3d1fd151d4b4", + "f752ee191eda425a597146a9186e9e375a7f55954eb434584dbe9074596e68bf", + "c4f3289a87c8da46b1569b8d0db93fab22d291cf8e6554d8d3aedde3cf5c1b59", + "a62547d10fb315c16caa0e2ba161171e5c37ebc5b072dd15309802a42c380397", + "30a306ead3d6edf311d2663098c20e5ccce0930f675578303086a16a402c434c", + "f482e2a71373567d37219592d4d06c7c5873f87c68539789c8652c2bd3c1334c", + "3471503deb7e83c286d8657d60454fb454edf311892ad248ccd946c8916c7ad8", + "338b93bd07f1d5bd0a1d4f5a616f2b39f3180b579497627a795aeb8bb08442ac", + "78f40b89cc831cd79155817d84271402a3ef5baa5f66d12ef5463321e8ce029e", + "41ce0c279baa543b47ae843eb21e72c7941cfc8f664d52c326f44a3d14c37947", + "4b594c50d94c9077162b26be89cd3938748f829e2add92c6ee5056c983cc1c2f", + "bb7db4f40b3aead0dde2a121bc6f7d1e2bb509bb3f2c20bc5089bdafc60a6d05", + "58325eda8c556ce845612911a9af97bc85088024036620f7053ec1e333595e45", + "292f5d470397dc136a8cf40036373d230b1a92de2fdd4a7ac906a49c48192e94", + "00e1c59a3effae424bd7775298a7b269e88c0521a1812d4b014dc9deb8cc6cbe", + "77917cc5acbae3b0f0daca3204482db056a707e0c063b6585a2e40041d7bfa2f", + "8f8a4cebe1707036723cc95597724250d4ec2a2b59d29040279cd83d1349aeba", + "fa692ba04929b6c0f776f306e63de0ce68eb3e54588d506e4026178b6685acb3", + "2a408a1a48011f152279dbd8d7ebf38683421f25201e74f817daf46cea6c85f8", + "61e4c2f4b6d86c944cf1c4e74b632e8dc9a6f412f96ba5a737bc0b7e769ed953", + "8cb788e183475185143e58fc3441801365652fe21c9d3506bd00aba3e5978435", + "0ff4290a34b414bc1e8acd98b9e8e33d75965373101d645c1df679b003e58c27", + "be8f765a39c253f9f9f5154e6d20024135d3a34e2e52497ebfed5fa7aaa83fb7", + "ddf5f72be199f590376f6eed7e53cd404b29acc61cf8602a031cf691bcce1006", + "ba0f900b25a28b8ca348e3541cc33ecd915db2e71ef1dec94dfc31fa2527ac18", + "32619d47f63a7a7fc5e58d7ad19a1035109fb69350f9de3d4f99f4870cb01f32", + "3cf13fb90b180bffcbd941534ea218663dcf896f7d1a0c2e3b26d7e113c68871", + "7a4ff30a89b6418b21e9cafa8487ab573e8c48c9e7d5c4f1738af86bc273643c", + "b6a73f24d866226b17b366b639b20a899291b233f6642aedc1525d19c889cbbe", + "33a8c2b78a3b6f328b982c533152d717f06df69ef2660f70a1f9bade4bd43edf", + "644f29cedf137a611e8be0bc0ab5c9bbff0b930cdef51687ec8ec22a7601af60", + "5d952f903fd2f07c3265b8172a6120972bba802072e1a94e7821c5e51c73d668", + "478eade967d7f5140ea0220f527234cac271fc5d17eaeea539274b9921b5e93e", + "705a5326ef7f711b0f34b754030313a18166a8c6651ca6b0592037debe52a987", + "85bd3f8b6ff2887f8341e61dafea936c6bc0bb3c8a73b429f0b9cef4cd7c183d", + "d83c81c5f1891ecb628b41d32609def8f449cca6a315a03310d03a7242ac13b3", + "d70f07dcc67de0b1101e02b134f7c60004ddf5b791163e7acf9fc2ffed5d64e2", + "d4906d0816933587c631b9aa3316c3d11e4838b6faa612d89419fe4fcfe13d76", + "c9e7822cedca145ab84c6d1b9da7ff83b2044ae86980d971e22973acc54c81d6", + "44edb7a7eb6b1b7091cd5fac20c20e75007edfb7b1a7e99ec268a5b7eeaf7298", + "d1b691af392da90ff4082e39deb331775cb21ab5b06057bda512799c94d1fef6", + "67ef291395afeacc775aeec376f7506fa20448529e4a39b1414f45574541cf96", + "c1b63ef79dc5fdc242a3f83c829d516bb6aee879c75dbedd4df2256944697bc1", + "588d118f24f674ca80e6b82bf2a78d2668dec1a8e072862d94d3fc1bb4e09ef3", + "6289bd037355e99f0025b080836515337b4071987a07f3b82fc10bf45b940086", + "41b50f34f7daaf8d5e52b61326b0235c324f75bdef21adc519c4f8e7b9e5fd78", + "13cc6cd354c781e4b6816cc3637d36325df6e0b4f02d5830509506a6df6c1e17", + "96ba6371ff083991f30fffe1329461863386e88e43eeff88d8e71ba65239a73e", + "5169d687b044fd6352ca1efe4a5bc4ffc65ff3e70e4eb8750370c7c29779d128", + "0c765170e83488a330d8c2b3a9fd384ed987287e42430760ab763568433c9790", + "a9de5bdce6361a7f3f87666433ad1e99512546423b539825561ba65d59ad05f5", + "6a0ed819ce56565bbf2a38c37a088219a4145aa9bcc8697ef67472c2e338b54e", + "ac6349e9f576d09ea619e66dcc932ae27c9686102847383606096d203eb990a9", + "3e957484dec062fba067d2c8b7e0d3d0bacd2a0cd11f99f259a104629457dd5b", + "7921118ecc24c2b789723c33f0c6fbdea0465d6be425a884aa12d36ce7ba774f", + "a21f4eeaa56b11e021b5fa616c163309fce86b867ab48f889b7bcb6ed3774cca", + "aec7adfecdd5875bad3070c15e9d64ba4a0d352c5b6f237d471443cf05ee1f73", + "d31b9dd7b49679cb06f50e46dd2b09ecc285a0b873b718967f5f8663c4199b6a", + "5364ad78a375f913c67d4ac9f9aae4ae5e04c84203bae7186dd504d87da384ec", + "fc3ec63c99c2a339085b19a54d4710d450d88b4c02635bc9a95b961869d8cac4", + "00aa76e274a59eae168e6af75d318d1c7fd44e83e9de070027aa396d1d2bc3c7", + "bdb6c5363d0c58bbed272f6569b2d0f5cf1fa770d7dd15890daff792f95eb301", + "6059b47411b7ee478d14425ad6a2166a03c84841bcf7e50ea4c000a23ac8ea4d", + "6bdf196d88d7851f7fe2f84dd1425356a5d6ddf6a9aa9d2c2c0341dec515e21c", + "7de7d5ac24abf2f10e9506d4da15b719121ba8f42a05e238b73ebb05519ee939", + "ef9fc88471c1d4ee83ed0a5e8923d162ff8799f233fd22cf1574c454ece618e1", + "f02bbdd76dd38a60f370ee44d65cb591a3c5ed420a37801b063214aa6ab45c67", + "32f714e7531786b79fc069d405407015f4b3a56fd7be30d16248090d5b02f61b", + "2b7332e02c0a863b1e4388f5696b8cec3ec2700bbf5e2ec7e85479ffef951e0c", + "e197287a8fc6657864c91f73848e01210549979acc88195994f8f5a302e86f50", + "32b2b126b933cbbc52029ee673d2df0298171542338b178fef7c44a78583ca92", + "97de00d15ef9f5187220b4ec3920f038d155ca031256d6dd96dfe58fa40feb83", + "fdb7ea55faf78c7d9ba823ae9b7e0cc3269b1c991b6bc64ad162597a54b6ef4a", + "3c6b6a7c126e541e3e413947dba6b4b9c699851013e1f532e46ba3041b4a8e33", + "67845a9dc4fea55563a6b350c698aca25e0d69af9166ab366911f5388946728e", + "c4e1cff5585ef9725715e3c263b2cfb136608e063438cc56fdfafd39ac1576ae", + "c8aa6a303db8f36d2532da5f79fc7296c5979b621e8e9c12ce82328161ff4970", + "d98e48017bab23678b2e3a9d7cc9a79092c46d306eccf3dd35c2e23a9f12228a", + "d29fa7d886401c159775099d2d1a978dd3b659f68a19d721185cdaf41add495c", + "386322d85f291a61be80b324bc148a116df1b56fc3851797c651da5a52a1291e", + "dc89110a8a617974f17ad2169cac56341c36efe90a63aee5cf8ab26d144a835e", + "ac65636fe612216847c51db440f51f41c23e60b68acf385c2bf0fed9839e8735", + "31bda7760afe9531ee206714e1e1970fdd781035666f765ce406bf740306a6a0", + "5a4bcd584c8fb1fc2760450b4045ea8415f68a210b92524645629265abb1ae61", + "e728cf5b42f9100da47cfc7c7195e5bc8b28b270f90489462cd98c2be1e7442e", + "89d67ae66f715e2c630abcd99820f48bbd5f913c1faa21057828be3002a7c0a8", + "3e607729f233c3350bd067c65686845eb4f7e9eb8631d38a32c52e8040ac4487", + "746eb674b82dd3bb87c27898d41cac90e1ff00e1d34f8e00491f71b54ef1f9d7", + "00db4c5f51cf271a75f1f8b3ffd1ff68bc938be66b69122c4161a552f061ba4b", + "7cd25cb4945f6ff27d8953577fefc6b7dc8081f573f044bddce711976e5559d4", + "701f77dd3fb4c93d96461706fead0a624a9056178e26131c30a63ad7fac87fe0", + "a51f764e96bd2e24dd6b40163cbf997432a83b3154ca12be520a3858f594afba", + "4634838ae13b5016d8e82312f81c176bb7e05bf4ca6e296515136ca75590b61b", + "4484693797fa70c31cd7e36a28603a64da7a6a5164dd0cd429a0acaaff6aa0a8", + "88a17575db3729fccc653fe071e402ec138cbca77329e46bd29f556740c7a65e", + "5defacc51938ce563be69c9e3f73f52ba215d3d02f4ebd7bef5fe2bf5fcc4b59", + "6ceb76a3382542720e2d433c8dde26049c61566da14d831ef90cd235e5425035", + "1bf72bf5f727e14f1b8df46bdf7e1fc91746550dafa8e69b7a583e1fb3709cfb", + "97661a41f4ca7358afd096b13be94f556c89fb8dbc331882c39faec16f4d98fa", + "14974c2560655ad6d07cd3d9d43796fc0816dde7aef59a6e72ff7a6c3e7ecbe8", + "fc3ffdce791df7dbe2a636efd9a766266bf54078484d55db89935a6af49b1720", + "0b6af074da929e2cb8b3e4383b2a7680477b629438869b7d9554e46f10e59fd6", + "931bf1a25024c8c4dad2874fe33cb16e03c65d95f0fe175cdc76c38a859b155d", + "0d518a0db8ba67e7adc5ec54fa1ed7b185db56aeaff037110d9ddc42bb217a95", + "72c04391088cb05181ee75d95e3de771d277a1d7c686cdfa4b5dfeb394bd7b37", + "a11dffddade545dba05ee6c276a39383b4eb1d0f99ae3d25ace370e7d147e55c", + "d948377a761a93ac07f28444740c23e8dbad3d9b515fe457a7e814b12a37e7bd", + "cd3154c3f23e9e44b808041e5b61582f24437a9260795e7521b3d46e6cd5a026", + "59508c81afbcf43a7d0f185214d3f8ce9ced7224496496213a540cbaeba63967", + "33d4016b7ce611912aace248265129a0715bc1541c5902edbd8cae48bfe0c771", + "6c35102179fb8b5b5ca28cf269a3067f09b60f9aa0b46f8a9ddff3b6bd972321", + "2b3827dcff90884255f2f01d6ef93f8e7b7dbd4cef15ae0670a704a49e6c42d4", + "6639377df843a5d9e409078ce930a5a2b53ef618664dda32497df280dcc26983", + "f9b0f3996bf9b476867af700546fcffb0cefeca6706d227061d14aaacababff2", + "4a9dafea5d5610ee5f7a31a16e7d6bd24d801d8736ad4a62dcc3885e050a68ec", + "05b29a5256f8981525976a2817f1346668f7809b7cc94df464c0e2fa9578fd3f", + "113310e22eccad4b65bdea25aef364650620822f8d3c9847d98852c148aceffe", + "7bddd389adfa9076467e72e7ebd3ceb5c4fba02d86731a075cfaf7fe6c319a85", + "372d1e685890ed828ad780296bf4718860e397e675492316d3be155c7dccad7a", + "19d8939e084dd30bf639548129b8e93193e5d067a323b05f12f4c8f67f99200a", + "b031c9e4ee641424d908c2b60bafe9c77ed0a2de93d9be04a8ee2059d9b1b991", + "1d933afc2f0fad27f422a7c2c8619e87ce5f5a9957474c9b71783744ef04d2e6", + "97c4dd4944bbdd35c81592bfd21802747657e8ef30c7cb5fd30071990812ad0b", + "dd695ec34872ca9caf52a07dd9f48257542edacbb142b1df352494e4a66b07af", + "50eef73b99a7e81a7471cb2cf5387a54188dcb6775f2cfc2ac84c136664006c3", + "61979bc8f71a5fb7e0af0e5cd82ea408dcdc2364b427addce710460c9ee86256", + "b798c5c6773cff8c9d5e78197679d175ee925b3281e6d9766efe9d33e6d6b5fd", + "3a3ec3594447ff7824aa9db9a188335f8906e1e71ebf0acf89c1923171b23d6a", + "51e1d4b627ef1f44edd5fd28d447af8fe3731db133e801fb107c9131df54c028", + "910c710733c80410b26cf3a60fd03a8f7310ccc51976d14d1015aef03986f8be", + "21e979b12797de35572659cb4ab34bb5896b0da868819af0e10e3c1ea57deee7", + "0926dc1d5e881455df1f004e135850ef3ae28c7589c7bfb3021d9a51c7f5f450", + "7b5300e43a3b37976ddf7381b35b810f9909458d660b012ff6bcd4adf98e7481", + "6d62bafa13bbbb06077a68bb65a32f4aa02324904fbcb18f273d8cbbded3bab9", + "dd6bc474fa6a5b3aaf9b5a1918c949f8eaa359049720acc32bd36ddcb8434f80", + "a082f9086d9991006640f5d2ce89e3b328af455b27467dccfe5705a630c49651", + "15d1db9bf2750261e6c76ede86618320bc1dad03a89a74b66c3b3002572baa8b", + "cd91ebdfd27483ca282bf7a58ba71b62d0efdc7b78a017cb22199d094a9bb068", + "326257b9d1d2334339982904795ba199b4d3675cfedb5145025df2ec2ca81cd5", + "e6beb89732d9f5e0d42e587febabcb3bb1f2c90431f4623ef68f6ccbf47560ba", + "0b56506bd5f73ffada0de2fd3c02fc3d6ff4cb17b62e2b7971f111b54acca64c", + "65f95456c6d72a82587b9829233bbe989c5c71913c2a6989b322b100256a29e7", + "6931b5be42d4f04944e531c261c8d6e42c4df17dd8bf7146a6e2dc691fd98863", + "3bb2618647aee2e74fd8a15a91cfd9738b96118dcba75f3b12f2ef8c9db2f50f", + "727510034d676addeadc9bb5061927d45294992f8e7b629577f56d51bb3416d6", + "201a40620b7adcf7dbeffc5db5dbfdd759e81d377b8c61cba80f51c92e31750c", + "0ca50dcf1d44a878c50c34d5ad688c8a68b349709adffb23f3f8da2876e7fb3d", + "29b8583da0383a80b1e3c5f523bf67f34253813d6fb828fb18a0ccf850f7ca7c", + "9247f04ebf11e1490424e5a210ab633771cde4a64f3ec537b63954817d1ebc5f", + "af3592b5a85e35238a6c37c71c55dc2236f189cfa1a2e62f1fe42e7410e92d9f", + "cade9327aa50aa1608f8a082dde69ae0561f4f80aa4c59974b0090143b75a024", + "9fcb07ed9685f1fce5bcdc494e5434a4fbda08cec511f696e810451987370f1e", + "115c487218231f67356f9421355c9de86676b3b46c68f618e94e36ac11dfa5c6", + "d7bdd6a7656b35629fcc776a9f2ddb72b1f125d18588436e24e4760a65a75ecb", + "fbf26fd70c5da9ca7adfbe32c87b5558dbdc38fbb9ba233e6338ea15573d926e", + "dde95ae5b434b498b4fc2ac11105fd7e2c36738c14b892ee312f483cebdc5bff", + "02b25529ce22a2dc54dca6dca06996ef594f9488b3a3fe3f2efa4da7123e51f2", + "b7c276e6fe06a5185af8b922ad00abcbe5202bcf27bc00f01382292db14a2760", + "48d980debc3257909801c87544bbc77c1cddf6fbbd2bdf0d5c8b9e4c7da5a76b", + "1ad17e5bb20a473587ffc06ee63065d091d0771ea00a6832988090694f47d019", + "b6d79da2aa3601e38bb2950418156163580516144cfc66c84409c86d9a4f4026", + "d328777f7982329939a72de6ca5b19219721548f9d6e8b785915f0e751cf1612", + "6509234995aa4e64f6520900b3d9749734a1d6efd88081db2a94be8b6d099fec", + "7b5333f04d92af6524bd83df041f611ba6832377d78414775f000299e165dbe5", + "98b88f4d61073d76724867a5b85484ac6c892a43963c680bad974f3608dddcd6", + "96c77893492ae2a0a1ab2bb683de5e5107ae340cae9977788010d68a58641970", + "a65b18de058364864cedc6bdb1d831063bb15220e06fe5226fd7e8cb4b4c5af4", + "58a468e04021b6ee78c3a8207e6607ce7dcb587887cb192631c9736a0de9cd54", + "cdf7993f170dff91a4ceef3f9b8cd7506e047b7111daf72a852300fa0fcbecd0", + "68f508f211b529714a6b789843501eac1f0bc6fb4be621dff62ec2f47152666d", + "641b400a277c97caa9318a098c5f0ab719c34510457a0c5e16f379856e03c9d3", + "be6a5ff7f5d0c40b27e9098f52a5e006a5b940a7a96e101c2d66efacaedd2b02", + "8278881104b7309b292145a74179114bb3e7ea8e6f5e20eede9c7bc0a6bb5b35", + "b6713317db1466d0af61ee915fbfd5264eafb75bd4a2cfefd58e1033847935bd", + "40b2a7205dc29ddb4020eda5f797806ff40cac31becab0651290e9fc2e3ee8a5", + "ad5120992ffcb58bb5a1b4ae48ddcbd703adf807e1665614d2f4206489402101", + "fcf8da61cc16c772c6a502766ba944e86996e5e9a8745be63961e2f02a6f7875", + "17cf8865e56aa2f21899a202c54382f2e9d188e0b834b52f46bd6c931449faaf", + "00d23ad8d9385ec9a76c996fd3fe3e7e8c8d56af13053c8555c97a06de152811", + "87a605f0f7c2150db027980cd51fc9ae280b3687ad421c2384aa92cf52efafbf", + "abc78be33ea777bb6116b6a37471400c653d0411681e77137e01a229c45517d6", + "9464239824271f00898b1055e22dbc96db6c2f7b4cf81afc6a12d69314d6e789", + "f49e8b7344c475245fe0f1e8f490a385495f99b20d68316438a9d11a0f67e4d3", + "9af6deae7e8176a2b3505814d74435c89f0b18387f558e92dc5a0d2e476a64cf", + "ba2e31d9f08cde780c9eccd2d473c67712e809287d44b07056e49ffc3e002fc2", + "bd259e73ec8425facffd104ae7e2191037d3266b433bcaecadcba2775cbb22d6", + "d4aab24985965ae5480ba9c600f8ab6c90ff43926ef7d37c7c2cd2a8a26ae48e", + "64444e6d733e6b4c11b167ed0c09aa7fb0eee9eab39a7131c2e23a94f5d84470", + "b2d79828c057a9a745d21315f0d08caed448da897255d830600348bacfba2773", + "b43b35c62b4a2762c621e1b1d6c5d9f0f78a78f41cea7dfbc2d7d8642c2cefa9", + "8b7a3daeb5f7bbf50cee92bb3b89d8fbe2a96cecfd73295ffc647dde51dace00", + "6c775e88d021ca4c90768c953fbd6b70c739b1949340fcc7f1515987848c79f3", + "382a5ba42fd309fd3b0191b4e3fea180d0e062d328e1b051488adbac6c507de7", + "edfb1a2b6ebe1b1e57a6bf1ccb10718ecc9b8d8acb01f1c10883b392d1dc4fe9", + "9ab858063a705984fb3797b9b6b56eb2607947a49ee79abc757db52d6104374f", + "2df02c57d8c8b194683a7803aee51c6d8bfbb93e0f2c03a0fa2377262191d807", + "c9104b8fcb11e79e6989ecf8b48bada0f5d80a666d07c1c18b9a974f63661933", + "7d2a0382b0b7b54f9e84070c52a977495b60fe481a900509ca924b76a2a74751", + "d08d3a478160b41983d572d331e39657d12f6e25f985d3917b18f3c58c741827", + "2c84c71b2c62e3bb26d10e400fd13c93a5db58184a8d56326564e1ab67717757", + "987dfada4cc58431d5542cd9f7e26b41967925b88993be8b938ef2cc66a54e3e", + "29520b5ffc6986fe73b1133a348979a9ecc14a84a25dd3fee1aba2b4e89a86d7", + "a254cd7fa680a49d87a45b1ea1379d0f41c47745240860242e9954bd64daed37", + "592fdcba0f9f8354d5279d20412e99927b281ab2936b21b1cb3fb024dc23d14d", + "7649e07b931f01d15c94f74851a4ad555b92f87a6e88fa841d8fc523bba5d553", + "49132b008f571e3251f75cfa4d951325b199c830f236714c27d3281d50557986", + "ccc6a79ca7da8744920b7e0664a01e8e46d43a90e3af181be14dc151ae437916", + "4e190f836b2bfb76e737c3c095d021fc0596b1438528d9801678ac80710fc641", + "0ecae9df37705c241f23509e80d1e5a846233ec1e032e40f0f03d2ddd3312ad2", + "f46b9f871709afef936a9fe4b02fb15d9b76c7be593411174d249367bb59dcb0", + "35bc02f03ba6764260b2ed73279e95266b6e9df8bf7b07e10f801a5884f8db95", + "b3d85469daf06f73daba9cc9d0ece7d8ac22640182fb596a9f41b8952682eeb2", + "95f9ef70e94db4c2aad34b293ea8db02da3f68635b4195c8366768fa00446263", + "645e97ad1af9be733a9d4c9d4b8cb3dc59769924dad95c3c761089d5a422bfa3", + "39f58de5847031e359de70ae2c6098cc2183361dfa36d0eaf7a1373ff3191bc1", + "5d09eaf0df0c6b02b51558409cdd6ba3b2308d9ea129b19163e54e181d83b912", + "88c0cd0afede5a51be526d580e1d3b1f1b24d6ece126e5374e9550ee9257ebee", + "f946dc724c6dec301cfe13850b2024d1968a6fed64867b043ef8d0a41a093c4d", + "e693b547ba5784e7d1d3e5043d1c8f5b08ab5ca09708cba66c64af4972a90ec1", + "97234996715b7705bb0172f3973fc81b3134b897cceeedb891e7708c59b6ae79", + "ef0f86ba242886c70d7c826b0d7b8a1714bf80dba658bc7ac53f069148b78a69", + "ce0817f9defb2786fc4a49d8761356c60701a373b602f962c02e467a5a968a30", + "c4980cbbc5ead8b58ee093e07857b1d3701f80e00858fa000de1179359915799", + "01231c829727e6d7b8d0a6cc3849a46288e8f3d4f512de0341f88259bb69e8c7", + "c5ae6f7533ebc57baf53babcfb85c6936a63be314c46c3bdabbb4678bed367ea", + "00e0b8ad7348f6e5b1a97c72c492ae2657d48a9371f5412b26f9f36318d5a5be", + "51ffce1db9c9629032a633d9dccf30cbb557825800e541c6da6787df4b41253f", + "5da2277cb2dccb7b5e661e4b617815ea3b84bb0e11529ef7c4c3f55350c258d6", + "8f53327f8c8329b3dfb66b9eb18a817babe9dbfaaa6c12f72f4b72b161072b0d", + "39a6b7ca518c1ad9531b12d35221cab4ec4ea0c057580328ff5656f2566a4d23", + "1cb748baab69aa5c5089917a124a94ae0d8e2f89be39e0a702b33bb81904d7f0", + "ccc38afd98eba8ee162aaaf48b24152269035dfabb128cfd8103d28338e80c8e", + "a9de9705ceb2003bf8bcd92276ca50385d71e39717be0a8bf29a4008f51cbe66", + "bd7fe6d5ab782758c9937fc376b9b42918f0a3f44abd36f8fbb2644d512c8e95", + "69eb741de886c87fe7fa391411005ae505936219a9a83086a6a82b0baddb2caf", + "c8b54408b6d0d746f6bdd8f09203049e977c8508314c2f37dca87de189bf7379", + "e8081c54408ae945774da9aeaf02b5b00a31ab998d07ed5ca18f93350bf91219", + "ca42c94db8260a50572a196af790b2262e575d55971f7cbd94e11fe4cd92a6c7", + "39033b3dc139c768d7fac479ff48a165b71518bd6e0915f618a40385deedd2b8", + "6d32fb89d592ab5042bc339784063c82bcbf7d74299a224eed557c3299549b5e", + "d2ad1e3c8cb03773228d6fcbe1050b8a0367b3c4c6c14f74e6caa47d86d7d592", + "8604268bae1e1b5cfd1581b068668463a0544491715ab36c38275e58529e5632", + "b157f6ab15658307b9b891107d729768dda40a1a483d3d010db367138de6bc8c", + "22b35e147ef9854c843fea90f6fbc9cb6aad4c70579c9bb968f9f560a276d5b4", + "c3199e5908c96284d0fa4de3a2d1d22bb3c99031441623f2b6c234630b6371b4", + "9520ca4396ee79d420882edee7eb081218d84e38359f31ae264ea615d3a03490", + "e4ef414fa5e704a5558dddf521b060961cd732de4f01248cac9ca4da733f97b8", + "69a967655e79d0d652af97494e8e83820883f194850ff360c1fb9405902b0812", + "9fb4912d4a8778a198533d84356727b268ba567cea2c3f247194e99dfd6305a2", + "d2dd7e1b6f2d4b15f99c0a93d0d4b336decab2676b5799ad227279104f343e72", + "4dc09053ed57b1a23ee6bc22e4f4fc519bd09da9489e5279969acbd30cef9475", + "070a666b8edc4d8066675691031759143bf4b16df3221da971ed598bc6ec2a38", + "9fc6ec4147deef3101a34292777bc4eb32446c970092878138baa578f0b42b04", + "359f65585f26bc545d55c2b100d15343ce8fb6265d57bdbcdb5035bee15ac01c", + "de7bce337b5d7e68ca2880496a44334b4fc69a29fdc78cc8e60828b017d2d41c", + "d9fe20d6116114f5904d1295ad83c13e4e375724f93f67022ca8d221e0ccff35", + "8faeb078b43b8eea8eb4e79e20ff9c2dc46c44261fbe8830bdb49ddb85cd0095", + "ebdd70222ee215b2d038e740e11ffd8b92b44e924255fd76c3d20a76e351f2c3", + "dd3a80778f1bc2e938e359d7b75bb458c9d7b08b48d2ef7071019c35d26b48a7", + "821fb1c787cc9380c3e49e6844a7ba623658c6c118ae20d0dec8a41057f827aa", + "a284d991862c79af3ff845ea5fe3846b7d916e323df36738c322ccc6994f2a9a", + "081f3178e929f87225f82603ee18cdf3bc4f797998be52bbefa425f7e918df94", + "f19da8a63327844e75259f041e33241d3fbaf331923f2388ba6e140c7adb6e23", + "7c87ae0eda14b396668853eeb8faf18d5f5e34fcac0dd226a3fa8db595f0bbe2", + "dc66cbf28fae7da3b1f0852b6bbd3a3206f054b0f859c2466315ee1f18a5ee74", + "93238f30950fa37821ee511599752be865c4c2a863b2d07409d4c46b5211d24b", + "2be52160719e8c716e118674d22f36e73f04c93a6370c10db07a40970836e679", + "561741738eac9957bab111fdc8797b0eb9eb3793e2186b2d9551f14c3d1cb143", + "3a7c8d0fbc4b1adceca6d400376e3823d6d5d7f54639dbc175b51ad1dd8e2142", + "1e323d063d4b7b5d1a21e4c404020b6e68056571ab7fdaf9d0736d2f31bfe208", + "689a9edacf4f3a471e77f5ccf43f8c1a5c08949b7a4b11935a413febbbb67bfe", + "8f3108af82515649452545cb5755118e36af8235b54fadede650ff9d9d63ac38", + "d85d3fe023b2cf046ad5f76224ff31dd9690b70b421ed718a715b4aea83b8b22", + "415016e869ceaf9de24e000aa1c5be93b51b5ac31738037c2c749067ca08cc40", + "0b26671279437f9f9a6052282abbe7c797100367b5c327f7a10a654993ccab24", + "fde1da32693754bbf4080a76e2defad78d88150770ea05837d361de657842af1", + "eeb045fc2907df58fe2041e332ac652944d9061ab1da93d170a7ef8eba0805a2", + "751a95fc355cf9d0cdf7755fb76ec59c6b92dbfca6d6b0833de248505d9a139f", + "dacce8604e2dd3808f77ffa2415464fd1d53e3bffe24f04a786d8b64cf60d680", + "db7a98f6908ea5c369916c962c2840e1faf7a65af0ade3a6db5b3782361b3f3c", + "aa1c4769b59332ef68b3dac3e34c434dd1aabd7ec9ebdb204533aac0cd00e684", + "7abe9483059804f77c72bd02aa3c0a8708c331b04d125b4f07b4d9dfd214865e", + "7803d89352953cb87a5b1aa875b5a32060ec93c853c28e81836b4d397c114c72", + "3e9a51edf58a1919eb551b6af185fce866d5cbfcbe757d46011ad5084f796f69", + "dbbfc04d99cc3591a749dbf8c193f6f33649e7e8f7939a0af19c9e2ab9e85c9c", + "209fc6b280527c8993735b338884bdcebc196fce1b4a61da7db0437a5d0033d9", + "6b574fedac24cef4926f1c69f1de3d215a1bb9cb2983c525d7611ecfe6bbe2c6", + "ff16c31a9fb8fc773946349fc32571dc54e30f39a4efb45fdf14f384513c4da8", + "1a864ed387fc3d052253b6bf173a3b1959768c7a5c34e105c3876da158d0ab75", + "3ffce337ef7a72bb7c3478ffc58bdef0b68d3e3e912e0e3ff21d3aac57487c64", + "e052f11529d4c6500fee8d5fd144de681629c8b30864014036bf50d6b0228ed2", + "b4d4dba49a365fd71e524f49dd4d8b345121d426da46c514199d674cfc0cc356", + "3bbbeeef5325aaeddccb210c8e62d7de092fba5aa4540b38942c5654b670ab69", + "3c4d5108792661f2937b269ceb4311e4a644f853bc452a2ad60a63803ab55e8d", + "38f6660176987a9a2d16d09b43ec473692667d5f8b8cc96d5814cbbd3215f3f6", + "a7dd58a48d1e2c7f70927e60d5f92176e6592d5fab26a1eeb0e963db18ebfdb6", + "eaae16718cde828d8469270401653e265590f233778b74591691f294104bcc31", + "4228f0fedcd27d58da126c5e97472c2a87633906de6f4c1d113b3a624f978b6c", + "1aefded0cc1a09631c7f434fc1f67cfb6cb7f52dcd995a715dda962681402443", + "513bdf1e477d9e1a84ead271e2568ee334c713085c5835e2ee83852db7621284", + "392ec9ea8418076987a81e6b9f272e8e7fb0fc471c82bd767f9fea934f1cae18", + "2ca35641b9adbbc1e2a08eae10dc0075bab928552526ee543518ed06e8e4408d", + "2136720d6689388591e83ade095d040c86381ebcaba62f582d57f5a7b5c0d06a", + "112ecd4b4b5046e42c2689f7fa76945487582b3ccaebc13c3ad0f142a382574d", + "6fc61b794adaee78eff82b1163cc06bc34bfbe8cf6eba76460c65a5025fd9d6c", + "2ef5b5ba7b5e0553909d8a3158d8e035ca3d13e429efc0777c05f617e4791cae", + "f4fcb08b2e900f3db0f1648f54bc95f3e9fa17b348856c0e5369adf714459142", + "ef0045662fdfc19d0a3f2e5311d5c869be9a3ba83328c0ad120900d59033cb15", + "cd574697e3298361cc53627e1c70224c22a900ee38ba145139fca600a0bf9881", + "2ecb11194c4b0d18b8d7a0c792f33702262017ac4a5fbd89951e8bb4ced84483", + "34e1ebc15ad170fabccbc38cf31ab41b8b5f270f9dec6219cb3c3cefc6257bd8", + "e7e84778ffb4d2c3fe2599fdf40e75264e5f281b45f47dd2efa84252e3ec38ad", + "e3a99567f562be9cb88e9385c21ed0c9bd69ab30d7050518da19a32546c68bfc", + "52e9a35b33c798f590d3a1fa9d4f2f551441b3c39550b5b7107781898b4fbdd2", + "c46dcfbb9c41d72ee33b6490d6902733b7b4f2e11c0415abe6dbb25a470a0533", + "71e08b4a89b74f14bda5c1885a3a16e052726fe3b4749d701fd278653579091a", + "44280e1626aa0f9892cc6a1fbe97a4935409c1622ef6c24a089e81057514af07", + "a38452ada34c862b989e25c847e96c5a893205ca31b800d359eb60ce36551283", + "adab350e90249a62f8b3fcef3994c9240eb7c8226c363b52ca5a4091c430d96e", + "1ab1da521aa7c18f5676c9195c4ac96b9b5c3be821450bb337d87a2a4ce65b15", + "5891e2af76fd427263a0517f1cd790cf710b7f74a7c4870abd1095d9c6418db9", + "90446486bab4ab6af8d0ebc16656a12d91f314e1701c891225926d1c92b7da55", + "134b7e5875db37422f9a02a7f9da135ce9089cff490ab6e12fa69ab509a60c4b", + "0bc38e1f4b5eb922bc5ee7800d4079fcbf8ecc404e586aead36bfc60418420c2", + "203c4cdbe30d00ef8d76fbaeb81077938252195eb0d73eb78ed942c2837b708e", + "dc87b9af6a01fb06a78034d1ba60f930ba730344c70145ce2a6f8ea10b909d81", + "38ddafd5bbd14ad15323b075dae7b3f20f72d5f722bb58925135377b77f2be01", + "889a8dbec852104b3a1004c418a599fe31fb24734c7c0c7e3658d8b231a81448", + "22a8498eb1de5f6ef32a8511a5bf46d54c95423426af92a9c31805fcb8f6e27e", + "911952b69b068864bb7ba0a3b6f8b9658724aecf4028880d5b1be875bcac69cc", + "84eac6b60112f7fb9b6bdf4b0ffd09fd7e7c91af7dcf25e7497de83b73299a49", + "879b71f981d86e1a1a8b931447daa523ba28075e9e254f728399df06f051cb2c", + "d0f102581a478395882d91830927dfb516e255d936048d8ad24d9eb5a2a10bad", + "25c9ca77290aafbb6d777c1726063000e8a934ae646b58e089d2a5348d96eb85", + "6aa8c5783f45894206d0fa72381b0080ba99cdc409bfe7f6e985eacb4cb455f1", + "4b96de128866e9bf7408fb38b0b64d2200aa28a0c46cfa3485da39ca819b385a", + "902bdb46838acd4b2fa5962b04871f0501f9af24142517a87d39aa1f0341b40e", + "adae1263b867b6bbd9d54dd7faf321780859f077887b27bef7f10fbdb051deb7", + "b33fd1a6d95d9dae75423523e3c038e254530915446cc7d4020960d2256ef04b", + "184edae0c461b9b5f13acc3c5d2151bca2705a7e2b2af09ae91dd4949acafe1c", + "ef3b676fd3f93dbcce81c98b34ed85281e7c5918fd27c71bd59079afb82b01ba", + "f916e385761230828bf8ea9586ad7f3f9b681b1a097c95fd4f6810e71d5af3a3", + "ea20b928adadaa90e990d05d2202d6659aa4af9bb4d668d81b25c054b72de725", + "35ed5513f3566c6f564405c820209861127e66cf0c3e9a69716e0ed0344d4b34", + "41f247d370e096d32d00891ec7795c469d5787915a3450364e986c98c3a35ac9", + "916eee31c9a6a3c3f7380487533e186926de172c347655403952265429cfbf7e", + "1800c25d85a42459fe1ca631777377acb8cfb70860cada9c1e0eedc55d446b6a", + "7b7b0a0e6a0da748247f01b404afe04382945b0fc93bd19920bfac0a86adb9bb", + "ef8e40ce92cbc5731b543aeab53a72c53d8f99b8ec4e37617a090e46bdf39120", + "50a1939e6bf2ce73de6d828833034b1616f46f0b87d872285b16599dfe910671", + "354f2435fae0fc28ffdc0f9d70257bf5bf839addafd1cb7dd561125ae83ac0da", + "a3b70da8735d404379871affd4af08c5e3c458679c1934b2acd52adf8917fd0c", + "e4bf9c4a2d4be9dba6afea03d96996d2a7595343ce1d361a195dfb6a099e066c", + "01e60bbdf74cac81a4df65d56602bf0a5c18eacb310b025463bf95fd71a74c77", + "edf8b5799981d7067ec55c818ac480c5a6285bc6460845991b6678b135fbd84e", + "fd96c93a173087d3cd0f9089064814e915083558ab328c7878dc7ed48b4b058d", + "c69db2be164f8dc206a7af93e02f9c69cadb7a93e3d7e366ccbe56c7d6b8cc38", + "38b296a208347a2af8397ea099e2e195fd2462ceaa4203ac346f1363b2d3dd12", + "3975bf8065007bbca007c3eff4e22bc1e70dd6efa076b26c869e4ab80c3f20b6", + "372f65a9ba156189c0cac0b560619b6f19c08ff509983a03740fa0ca937ed7a2", + "abe60717a73dd6889a3f38cc988e6c29a59475240e23b6fa9eb647f2e40c42fb", + "cb0af8d891b20d48d23e2f213914030fe4c670bf5ed462fecb6633400d8c8973", + "d0dc2ee20eda05d11457c84aa624bae023248c189d6458a1b6ab0ce8e87b544e", + "b27c3295155462321fc9b9905880da24174ba6f8c44ad4be488a6cc5af629ac0", + "eae4cfe7444dbd3cf8ad3ad6ebccfa79999edb210b45e7b9b6d86576c7edd3ad", + "fb1e30e00d0f3d80872740c7adb55a64d248021c8bc0e42c6fbe6aa835dd4c34", + "91f332c422081c6f3dda858fb57e8054333da82f6c535b53377660f8ae33a999", + "caa0c3de643707a2e2363c53148e7f9c1996d78ab2ae2a83916ca6371859ce86", + "06c5861fe5d3b47b6d05a29d74e2e294fa367f7cac17d67d0f4cf034a227147e", + "ffa9fff2e738689a985bb03d4a00ad19936cddba76a018aea65572ed93b00138", + "426dd284343c9c62caf0ae18b73b60cd029e5f2b5fa4e7e86d4fee77b3fb46ed", + "23d56ac59b6a64579458690fadd82cc49095a8288ebf7f68d4cc162a163b7eb6", + "67e987ba5278a01f10dbea9bceddd43f70ebe05f7d3384c8bd0dc60f357f24d2", + "57088edc67c7bca6b5710d16fb436070905d2e6e6ca66f1977c7a2326c24adb1", + "b2b8a44440a7137b3587bd4ef58e7bebdd41d1181901be7147ace1226bc6b10c", + "2bcb4748ccc39d6a02c065aa2b5225a6a7e138e25008f14722e79975e684f990", + "6b4ad6c9911f27a4a9077e78de2db27ed16805f8b98a52f342d53d3f175e252d", + "fc07ec4605fb4656e0b22b3a4400ea9946090b84a2c0a67dca94b8c9517e0dba", + "6719f5cb6d7bcd83a685fd34856096bc321f169591865f8ad115ad594fa67ebc", + "512e56841887514ce5fbefaa45218f0c3552d5219be847cb4ee9801ffc541e70", + "78c5e266684be3a8b316d81e6cb343c5783a3cdeb2a8b4cf3d09f4753ef15650", + "f7bfeec282f6ba877d0e1af4c435f01c1efdf61481f5dbde9cfdc181bc027365", + "497ebfa6d755566bc383ae6711533e03d2e47055513d554388055d37cce95799", + "ad05549c277bc13483f004029ff702f3b91fe2785a57c753466ebf48f2471397", + "2244faf3c9cb1ee6eb0891521348a284edfc200e5129f05bf8deaff30be3c02f", + "b47ce6f1ce6053361fdf2d3d6aaf10f88a94554ac1a0256b72c2eb5543959f15", + "291f602fa0edf9708463da7afd29a9e1d04b44206f944b659a5f27a0bf83a57b", + "4576f8079b27fc3a69c763db4f1cd5f1042eda3c9db7fac80584679f000b09c6", + "278d4e554a21c73b783781a53dc9f6e18ccde1b8cc655ebf6917402902055d41", + "106812c0b2636438bc93a06aa5fd76bc402ea91cd1180c6031573aac42e53662", + "8957e82960e29460f42d473b101311f82bef700424f99afd514ace8cfcdb1eec", + "454796efb24031555e1f54eb4324dd9cc5e1a84d068cf104bdfde70ffda1d423", + "8eaab7fc4427ca9a367dceded599c8aba6b9c7a93de5ce3860e3a328a4ebeb76", + "69f844727416d40daab81fe9fc3007889594fa6c5fce797e2a97ebe4819bb345", + "0a668bf98379541778590c903e209dd4c611ce55b1c7704aeece3eda236b4e26", + "234db34a84a0c88b978a09865d333d8f8a03a68c662a835f9a4a090821a00beb", + "c2f10b88e1a3179c76f0af6e42ba8de21c1029b17eb4d9f256c159e1a9863dcc", + "6a56cbb44d8f09e383badee50c33ffb4cb893ec98499a195dbf67e4caeb75c33", + "f62fd0962a610a5777b7e4d06c11150a622a510e55b646af56e64bdc87a2f579", + "f29e504c187a4b512f70f9390f30a7ef59c6331b0ef7177ebfa2b5f5b42eea5b", + "e5d1bb4f2b6a6aabfd56c6753bd9a6830d9fdee4dfe7015e8ee38d994eadf1a2", + "aec01dbc3c9df14d2709a3e8dd5ecabd9a16487d09516b201819cc2a692bc145", + "7a4390b3d35ca7775c9be00d453c55960f98f821993a75b2a3625a162e3590ca", + "b02730458d3cfcddebd6a2ecfdd81d031104c0d185f749750ecaab8c68057e17", + "2a49873f66a0d8b2796639bf29cbeaa453ae86b65419b0e8263655b681c3177d", + "d79d30f819fffc483278f591e0c959aa2ee5e0ab1d73b0d83b6566b02585c183", + "ab1fe8fec5a853af3cd38c1294b8325e12d064210b88d5f2c091191904611956", + "34e38f2dcf1e9a07a8e0822a112ca0d5e1694d29928dbeb305b32353e7b79b17", + "7b3ff8f59ce06f122689556f0fb70fca95cb0136e776c9357129ec6e930248b6", + "8418891522ab768be0ddddcbb631e3402a12f23909cfcf3177e64483f9ee10ce", + "078b17afeff58161fc32b700c966cc4d73e60a3591b6d904cd347fb24c4e9e45", + "434116bdcb2900113245993358b460797e440acf9903e6ba4f012e45cedc1c9d", + "a39582ee090dae8bf7d6eb1dec87f9660368cd74454b17c3d2d7b8ad1345bc2a", + "61fdb3cb109a1cc33551814416b211f4570b8008144a23b43c0bb6a3d75cb21c", + "585bb60cf680cabca88b09dc93919f6c171720c407ae1434980e26d9a7ad8c7d", + "6c8c6ba25a1a25870f53e6aaa3e1dd6f991dc67b373d85c9ae27ad908d4fc9ed", + "5dba5a4eaaa93f2f65107d4995bce492249ad3c796068f53b31b1b7107b0e927", + "de1603cf9353abf15c5c39572e5c554c064ffe05536c67ecff1b71298eb7ef70", + "b0a12c56b3ca59d98c505939425c7e5df3b74455d662d97da9a4071732790f81", + "6b51bac9b71e32a46610577ef9907b2f22546c5b5dc5a948e2f4a54d5fd8672e", + "b4a8991038b15aa0dec531df7fa60c5cbaae1bdaba6c23780294d053a04bd923", + "a81dcaa233e3287221b5ac0763a61f2cfe759c3a05e791a3e0936d4d0681a229", + "277f5c9d0ddfc4d073ba4214f28c2d340bedf8e9cc060e273ce859511a9eba30", + "66cea987fef58d4cccb12bc4a75916beb651f388a710327bb04b8d4c37116882", + "e32bca2f823a81d861405019b139ac5555af12a6599b8b76677595267cb2dfa7", + "dc3a12ca3254e8008bed09a2b1338e9afaa17367a51efac476860e3d4e0a29be", + "e14fd8e5d9f1532b5f0d04a6f96e5d7c7a80841e950dcbf5b2ff3d6896f4e0ba", + "23d6d0b3f9b79c3714b32eba1c5e268eadd94ae97b2b8ffb0c449cb55e44f79b", + "ffa45e28441fd5d295faa03d528cdc43418654c513d13e9c9c0a5a8111d420f6", + "1920c7ba51ce23566d9671e0ed0d470291340a91d103d2be0a169db8bf901b13", + "74f8c5c129c0f26c19f099243252d730e391ba1f0914f61ada535034c0febab5", + "e4c40a65ba85fef2e29938b15575ad20f49b51618dc4bf797a40f02ec02c157b", + "6b25b564ff49cad60192f9cc1e827ce8340cb50d38f17d4e9d2b57a3e1f34020", + "a04a213f68dd29b906d71320b5f9842ca67b10cdb20d4214a2137a9f85286458", + "90a2fcea6bd9a252d8fbe93624275d41625a857fdb38dacfe596fc51713fa8f4", + "eb1348deb86e7102fe272752a0965f5d1f05efbe5963b75aaf169a919f8ab59d", + "65ac93624665fb2f18ef53f1e4b96920fa065b2b74a216808dda059927960324", + "0e7bca835b147853684843ca0cb1d7036d9c923c2ff5e3927a03def30aaa38c9", + "6eb8629351046b8b2280fec7bdabb509832ae0c479c5ef69eb67df751801e7af", + "d33a51787e0f3e107b3ef4d6d896b3708151a61c7d20b779fe20e65ee4d80174", + "56c5ef175d6e302888f3a43386b98c5e45b6c59866132106b341d33359cd1196", + "cfdd43b716e3c0b6b11b1369af1e65e616c0b4bb4f130a669f6722ce864488d9", + "4a960343f8ad676fc3b62daa065a5ce1e418c4edceda3a40adf338db8b34cea7", + "bcfe1f6943c66cb87eb9e4b3eb4d9a36c457f380b67530ac6ae21812fcb3db00", + "66c54e0f83d80aea962662df883e0892edf041c381dcf01d8e10d7e06bb5bde5", + "5ffb32276d8ee5c4b267f291a455481838c8c0ed5c98d83061c091af31cd6dc0", + "aa16b81f1dcbe8171e8a111834b026fc310f8fec641d1ca318d79f804fc2a124", + "7324c6eba4eb949f93a8a65ece3694a8673bf384ab693d1e09890ad7fa058a29", + "2943bf4011b06258e7a3b8c1d0779cb5a766f65022820f33fed31788248e0ec0", + "8c61ed033508ba80142794d7009e0fc73ad3e4cd11400e0b4b7efa398e2e8c04", + "0e4ea8db2bab026506a6d18d1cb843f4eaaaa9c7be8612cd06bfd6a7394197bc", + "86504135fc1aa4801caba1bb7793a820c148a6d4cefbe592f54e08ef2dde3f8e", + "78301da5fc245da790e0acca4ca23454cdd03be108dd069f36d31209ec47ffc2", + "0d8df6b77a1a44bc3ecbf7f64df73fa764832151c327e5cb2a4793b3591a224e", + "cdde7a7c34edce91e0d7025e5bf6a500b2b555048304ab3d85d26981c6451587", + "6c043a7fe10428742ec3447f3d7a6a5f7c360fd473578d0554c8df08a9d129bc", + "b66548316a3cc97ee5956ad6f96ef3f6546294440d428ce4d0c0d9627e315ddd", + "413a3d292b50c3bd8449365cbfc2b5b72d9ba844f8e3510cb4098ab6f745383a", + "6365d91a8acd23af54bdacf46bf9e27181665f8fa72c68d785de12d1aa20e5a2", + "07699516f442d7769b0145c4deaea9eb232840029857239401405ece9d5784be", + "f4ed5743f6e5ea722b69be65493389e343b1e1cae715feafc9308fa563970528", + "f160a9998dc5dec8e406390ec4106718df9be838adb4d0a3f084b33ed7d5c4be", + "9c17f1aad70edf87177caa4bb85f8c1022702dc5430d0f63a2e91c0b7cc03e94", + "09af01cd09540391357de61f6ba72eebcf83817550ce922a1216ed77ae94ab77", + "6f9a2edbd90320e5e4b642b47cbeb904ba33a5bafd9fe7d1a3696d46f2741b05", + "4ec5a8abbefd15ad6e413453fd0d12b8fe9d5880f0713373fb22a71ee02a26ee", + "7188fb4acbe7cff99cd15fd851e556c919f4a3d1142c505ef0b641ecda2925db", + "d9eb4994279630fe03b2f705c41f780e270d3bb19fd9a9269844fdd3dea7db08", + "02fee5a7211acb9e7abf8328c21ba8b68a839a6f67e63145f1d252aedb14e809", + "2c3d1c9670b9e143dcb50a5666c7d5f56758719ced5b43ca509836b060c6f448", + "ba9e1bf45ba9c3fea8c933a7db4dfdb07c66ab6dcd63426d95f182bdd492b0af", + "0270345d42b5661426b40404e437eba9e778fe2cc18e29e49310ee614fb7e255", + "3e755ade5764300d448d18d10eaa233ee67f03cd54ffe1e3084c6df380f3e29d", + "8078b7cdcfe5f3592a39f2f4eab079a9dd783dda9d176022e580339ad1f3f5bf", + "f64d0b75c10f92e15ca629021cfbab57651e4ceb9f5260836c0f3a878b7b2dc3", + "5a84c0a0e412da44785f1377c9554dcf82558ff3f952985e66e8135cdc9fde64", + "94519af01bf12980c72d4ff8f559cbcc2f1518bf8646605ea940481a438e722b", + "3397a93e2b1c6ef0a0fb50951abb41dcb04c8d030d75a79a56a24c312fd7b0eb", + "0b6a259061ca0126aeaa775c506f6819ecf8e9e0a3f829a306778b7f70058b91", + "900224a92755a975f2d54ebf7e5ea8d638ab3a3bb956aec2422f5e557f8c6e65", + "5bb52cc3a54c65825a5420095234214a94f69df60b6aa8772117be003a37e079", + "90d04908bca305acb770bfcd62ad01edeb872d2d8c136021d0471bcf1b682cd9", + "400a1f891c232f99487cc225779a3577a6620400fa1c2a90a0452c3dd803880c", + "0109edc5030c5632777326618d9ae3c00880c4a9a6494661c8bd4860d5bc6f59", + "3bbbb85759a8a91748ad55c22f2934c8301a19f8ba5e963c0ad87bb03bb0a731", + "8229829aff30531db00650d10c7fa22a5c183c725c38d4f1e01fc011caeecfb3", + "7712ddb865540846ba99c2a391280868d636fe29cfe6b51b3114d91e55387adc", + "251e17aef0b63ad44588507013b75ecef1d69daeafd77a61f850c6418f05b00e", + "9fb0e69f1e1c846e1d6da14012f8bf97a2ae29cdf4ad332a9802aa6d4b11ca2f", + "80cd77cfddf4bb7cdf453dc16f7256e73735a24606826c981f17e57ecaa89971", + "3fb7fdc876855419ed72487e32a1cccdbc93258a24bbd29525ef9c69f8744b16", + "b9a9c199ed28b7a612468441dcd7b1383eda5c4c1cb3de546c3474e9f900dc93", + "c1d1bbe87518064fdbfe95d9943ff73c19404453c6286c57672f8f60d2cba6b8", + "9e53530b5e761686e2d089b9663b7f15020c28bddef386f505eb144a48071a51", + "ce57acbcc1f0d7e9175d3a4a8658b289b4a4eea0df29ff4464f491dbcf0c2724", + "afd80287ea9957fff1ce700b185becb642a7230e042371be8aaf9b589f24f09f", + "b578e201750c63082cd5da4d85344476e3539786d6478c7027d523428a44c11f", + "4630434e419682b2f336b0ecdd7170b0d292c6e47444bb589c3218351346e0d3", + "bd283bfcf41739c3d456a3fe2dcf0578d3dc1c3152727be06c4f69fe1b973c75", + "7ae3f949a3f758eee6e1bb76662d119030008a7cdd0eefca75b26204a8465aeb", + "a43b00913fa2f3a46b331638fb1b702eaab4f048e9d33f0272f0194cbc688ca1", + "8079d181f48c461efcafd6c0a4babf3985bf6bdad28d51f4f533d78f7a2c539b", + "3caae969d76c9874be9f9a65849a59bac11ff5cd42d48ea7a39c2a1a43724bd5", + "3555d0b57cbeaef93dfd7e3b28a4c2c2b4ba0f40aea22b4761642b2cfd7dcbc0", + "d44a93754096928484298d3d7a295f3196bde72b0ba5959b5d1532dfae874cb0", + "fec8ab7d63ba07129d4e23c5bc15e6bc8f5f5407a0841eea8d924b51d221fe89", + "3e0948eb2a34ec5323de183be06693304d8dabf98a9d8101afd017dec98d511e", + "4167fcdc162af47bcaaf8d0f035cb9b4dbc033e6c2b831b2210e18a9a96c5d79", + "483ce1d14e5608a92e34c7727192d43a64f6af93a74eeabf11753c691c70d0f0", + "38d3195fb2def60a4e78478814a9007b5f24682935bf91cf3d309bff524be950", + "39546ab2e121ea07f8f09dd628813d97799313f23fd20dc926c60e9aac719b98", + "c314ad76618e855d997dba5fd32f503c05e5206688a6cc0457e876edbefff39b", + "331de8eb5f96247a2ea55d5ca3481f7cf111fb0fce3c17e05abe4818a292d08c", + "65b8cccd287f890167a044164bf4893e0d3d2885178d74c1017053293f3545df", + "49436f235f532ee59b31a1401c77505ce7d60fa96592a7a6fe8143b68e6bb16f", + "2a7c4918652a26015f49f67940714d3c153b10c70cbdabcc2206ba62f506b1c0", + "414a24d8877af1dc26294db4b901193bcd0856982ae8cda3bfd2ebbde0214a90", + "600b27a06787fdc27e1dba8cbd3507dbf377dc0ef9b7050c6a6a7516c324ec42", + "123ccff01a6c53a0322fcf0d3fd755b906dd5b5130c5af263020a5d5488f4164", + "71dad5f539159e212a375ba2ffcb42fa48c7f3be4b85ab067135967c9f96c097", + "53803809bb37bf129185e22ab767c9a21a388bf3820464d271265c6a1a6f6998", + "7ade721391914286ffc886ba4dea0094fc3228c880c9a321cac6f960ccc1e430", + "f08847c07bde473da493042c4be319d33f5f3359d1443c3ff9f89dfbf9dec528", + "e3b385e932bdc3494249356c327daa0b838a8a31c5a19545d731cfb5160622ab", + "488a83229873b36b241da7d216c077d1c4e8965e33a454fc2a41c132df92e161", + "59213a19a0c703d66bc6289450cc691d6630c89bf1a8190d0e989361a121db14", + "0c894a7414e2c6458586e73d21c319698e6f2310f55e4922d65b3087301e828f", + "c0cc1a44003a8b39505ef4272990b349e092c5cbca1a16b191062adbfec482c4", + "6fd7ffc09029501cf498f763e6f4a5e10e340f28b27d893aa802b43eb62af673", + "34b0461bab9bdb91043e8e5fae66f99efe1b72bc550d8b6517c82c636f26477b", + "75cf3715aa3150ff73c92be4611543b6215246e91cfeef0c94bc83e39159cdbb", + "0594a9da97559521d4e6975d493ba470d99625960a1f34fe42a8511139c44683", + "a8c1e4b175d7f7902039ed029ed58e158dba7f1abdb4bcccb85a9429c2a864aa", + "7beaa4fea80d98f98c95af5a67c0fedf56e85a37dae5785d2e05a821243f60e1", + "959d867e711d0aa6984fc5dd629cff3a114487b23ca3f412f99624d492a3d51a", + "a8798933729789ea42189305c3006dea8f5cad506cb8149e0d86ace4e68f0b5e", + "11550654e7e3d72f04ff77742f4fdec6c541be5092f691f089ed26935af50302", + "1370f40fdff7162d68a9eeb10a9217b2a57e5ad3649d90aa37eb0ab25a5f1ff9", + "a96189803764658b78af7901181f13e898eef78abc9d3a4d285a52652502ac15", + "fb618e7672d1a3c85f1ba8dc62df541adc19cf008819213caf41eb574dbb8dba", + "42312e0211f133dab9c832d619c97088ac3a945d321fa071ba50210b7a291d37", + "5c84a0ad3f5b1c613a4ffdd3a50cb655a42669b6bd85ad7bb83b459f3e2205c7", + "c57989a8178de412261725a28704f66d29963ed1830a8ea9b224bef02ade3807", + "ba893d5de01d6408d36df4b5f58b28f7d37f444973a97306c2174df92b6322a6", + "5520efabc5b4b9bc40691276f63a421d7e544ce57e5fd9037b1467245fb0be47", + "49080fc45008e739f5cfb72f61064993f3039b9d43380f7ad7961afffd19ad2b", + "09001b36b86ef07eac1dcb45e084294556c0dd559589c6f73711527d98510c89", + "42ab47b2b9780ae2c5b402e9f0659ed3d1391d5c3342c69d8410b9b376e2283b", + "ccb350786dae054c5d02ebd71b51910b1185fea2a5f2e77014b74ddb8b2cd50d", + "2677a46d8f39debd40656529fdc06ce69ab87a4239ec44ae5a952b888552efdb", + "a9702d5b2f12c40390fb9ac4adb773bb67096bf1c34404e7a5826e33f2fcb1c7", + "172d9fdf19374f114892cb2a6967f6ddc90b1bc4fcf7f8a3eeea2596417e3869", + "fca5c08c7574ebfd76d746876be3ab8c9d7a5f8f95bcb08b90fd9abefad7ee61", + "a80a6b6641c608071af1416360511f483f04b196650784f26df6d227ffb43a7e", + "3e011381dc0c30a1ea0181f9710f650865d1a7d8d815ccd8e5960adb21d77671", + "89e6e3c096b4dfa2c6fb8a90c389f1959c17b63fcf79c5d78f106f03ffa9b69f", + "b7f55a2f7b39791686e97ee26487ec86721bfa95a004c86cc2293b62745d1a9b", + "ebaa988580b15a617baaa0ca2a8a1e13b13da9ef85231cba8a4b0d30e8321ef6", + "08d1260706b32e0325aab051d576a98d557b7208c0a66a2ad4e8160d9a7cc8ce", + "b8ed320a4c399dce8b95536984d222e88f884663675234261406eabb90efc817", + "49a3faeb2339028c1315f961ffe4cbf7426c4a71460cadd416b606fba3102a2f", + "772233f5f7a0d2808806ee7c53541b8af9dca35b697b66348f1ab3e1934d0074", + "f6c61a66aa1b34574b3621bba37b58e671905ede5de266cecb7fb2b836cf5ce5", + "5390f1976ad02c3468ed8ebc94c0cf3d9fbc1aca720109761a432e4bd49e4ab3", + "6445421a7a3fce1620ec6a972ca78e1e387c87c0118d6e1d2287f67aaaa48810", + "bc510d67887a115619863bd6926150cddf7d5fff41c02ebb87b94574f8c9f1e0", + "6a7a6cccd2436eb40c66432f749c56c1e791cca2844042f472c72c28aef87454", + "f055c368d2df04d10fd3b9657f76d4b0ce8202a5d6dcca550aa943176cd35b25", + "10068b4bf7a3762e0456793a8cda2c7bdec613143f39e0d7e6f6f6433fadb6de", + "0fff610b3f319ec95964e3411590379ca64873427abcd9bb74656e46ca344148", + "4cc0947ee12b5fb8bff191160dab764c22ddc751c49a76a4b48d630482c83323", + "7c956421ddad646905c41278721ec43fa66bf0703c88e61375f6aaa529b63786", + "d45ec1726bdf0c39dfbd4169980d5b4b4f076b9dfaf9f53f2658bfbdf91334cc", + "5e22fe315467691602e00083674b90527c1bfd21797d15a64d742e877bfc0bdd", + "95b9d241a1c2cb96f9eb9e52ed53c50a780ef65f5795b3add0e26ee234833045", + "1c8fbbfbd9e6eea4432ef37815d5888caad0ace5ff38d39a0fbaf5df5bfdfce4", + "4343e402a7d0688bc119dbc468bddaff3b536f9480aee57f72f277d19b0b6a4f", + "16324a27ec0ccfab373bbd91e4d854ae091b2109edb68504edd884f1c65d8638", + "8f44d2fbea733f16fe3918db8f52dbd6623dc82b07f27c7027885f105ca3b4a0", + "e432a438d8231e30adc28a26dade610feca80a1d76387a81210d3f01aa0047e6", + "3d693087045fa49f4e1994ca8ba354ba77761829237eff3c9ceea4061bb3943c", + "0690c2863f55498f7c0ca00a2dfcf516e2b5010a6094801857ee60fed840f7ef", + "e00bbd533df149c58aba4b15e2374db6df196861000be4b871ec0694b256c779", + "438e02c71b21ea0a33bacb67714ab2c32c19fd14d9c0902719d062f34967bbc7", + "866c1f8f2d46c2fdfcbcd8899b3891bd6197a514440cf6b8d4d40389cd496a15", + "24d5636a396d13ea19249fb654a2648beae7798f8f9c659be01bfb326a79dee8", + "78641ec909367561e6ea4ee11df39b81690e32529d833a8b5ff2b8b440d3c89a", + "5a93ed93cfe6fbe0dec8a115f7e94e7b4b42a4fcca36b24bcac9de5e16e7ff73", + "40ffbe8da750642ca2703a8d79b605b4b8a4c2c2dcd45a1f802ac96ed61c2a17", + "58f958dad21df617b8eac3e651085991ece814b9bf8b42f75358cc9c44bf6cb7", + "ed426a2a9f644925cc76c763b745a94c0e103efd64d358625f4cf9fd165d38e7", + "033dbee5e0d866fc3164bc3fb0f75e6ddca88d26420d1dfd026b7419663b8f4f", + "edde19f6a7e5b7a5867beb1abde767535384c1a1bf91b146657e3a4c9069f58a", + "afe2eaabcaf5fd7b26e9f7637375885fb6f2d0fd26d988651046a6006da36941", + "83a51e423e589cc2ad00fde729bd382876542278b1b239c7e47d8532b5f4d847", + "42b165f2b220dd6139f00fea73581a342d2253810fe0a979d65ee668d4ad82ba", + "0111a4530474519c340d2bc3c9d90004b666eee15f4f22b011a45fed54fbb26c", + "276585f3795c45445f11d48730daf56312a216b7f5ddc7610426823cdb9def83", + "65394f36c2f384911cdda510396913a2afb2a20bee1a75238acf164b0e52c683", + "97711284cdb5f78e662ce908fee040faf19e37a00d6692c7a6ecf9b0143e6afc", + "f54ee960972893e0b09ea905a425c6c33857a4a40b848a390eb20aa13d1814ff", + "bc63159ed83fc06c2d921febd0129fe37872bec1ca4cdaa17107c41eb66ec6b5", + "c7129ad3398579d5969264bae0f5dbe075873638e1e0680deb4d68bbc0ad9f25", + "47de1f5a34906212e32f3f6af2146a8e11ff32386f2ff6309e6932eac428e07c", + "b1e5e4335a4e09868b8f23e8b8fae5dcf7b0dd35cb5fcf3965f1ad4162874f58", + "2cc7b91bcb841d6af3e45c6dfdaee4f81645d1b6cc3c79e071e55b259b4b4315", + "c5bf3946b7a346d4c4596f808cdf083217660aff8864f3e47ca869cea384dc06", + "fd68c1293d21fa5e9150298222daa3f90847b3e1f877255f9767c259bb7820d3", + "66c728daa5a089a2f045aaaf365b283512f5305c13a790bf0dfc6d8d69e95f1e", + "63d4a74ee476c84e2ee5a0b3341cca8d8097a76fa58f9893688882a3b2392918", + "d9de6f992db8df1eb04f101b82ea33fbb52ab7054c238eba0c8cdb0b2ce3b864", + "7314a1478ec47e1ccf478ee629ab273dc820460f97fc0c2de1ccfe43b15710f9", + "8bf84fbc47f686cdb4b6f73c5c7fc710e1816e92fccf9d61c31bab614ccb25a5", + "71572622e2f98e50443ceadcc5fb55ba438a8fbb3d5f6bf9af66c1340e23e7e7", + "e69f493333ab22f75565e9294a9e3ae460c7f523e79ab2e76bdf8c74be21ec87", + "f08cace2b013b94643dbd8ee1e14427ecc766a7743c1fb559a1b5ad71ab935eb", + "c10f4227d38cc19b6c6aaf8ca3433e639316207678c28834d55233a9c2310ec0", + "71cb50fbcc62694c06dff9f5a9b2bb6aa2399fb5fd7034a16851f0dd226506c4", + "b6fba7f0e0ba0ab83b2fad2938ca198c535a7cb35f16e116e5ed5d3c5abaa8a3", + "af67837de71c55058f5d79105df02c973d40fa0210301065e7c0500be0e3a51b", + "f60d0bcdbb9c99eae1f3f05d7ebb8a949f41f8da80a0bac4d7dab3dd42553161", + "403b7005dd7bcf5f8c3195086e4581a7bfc1a810a5f1f34cfdab09897f1431c9", + "5d55d8ad7a719ba487c418a184814b65ce85ccedf3e5f1d793f1a92167e15138", + "0da3f39f14a877503a3e83951967bbf523f5788b4eaf2aad8849fc5f45fc7ac9", + "85513a1872f2ff0b0721008f60a49c1a392e34cac5a3ea25848d54def38ab7c5", + "4acf9ee2111e86bb82f6248389b306770af0042420e12d16547954d0d28775fb", + "1a8ddadaeb9784fa117e21ec9e80be6da04aa1ffc558a1853898a22d8f2fc090", + "e4c3cd0af6c4f618e55a51e96c76df2d0460672715508162a5a85c8a00e70c21", + "978ff0c303fccfef89571f57985f8349507a0c1d2d585f0dfc44a4cb4fafd1af", + "5174d8cbda71f837567a495d08d4647b7d6e490e4814150ed146a0b429e528a0", + "7594cee3b7fb88685fe00ee8aa1827abb8cfc2dd57b70881c17b0fd3cce2f3a9", + "372e3c3d90506c64bb867aa7452d73eaddd513a4b4ef789ab06650ee20fee844", + "404499a5c687204feba5c81173355257692a63a04279152b1583d382040d6b40", + "d748c7eddef2518b1204ca0486c7a37df9694ea75b1c2d9924a430feef4f7d79", + "8cd0be7aa5fc8749b6ce541ff5eea8e0078e57c3ef444ed045d6b81ae4c89e58", + "d9d8cc9b342c7cb3b7c6ece13055b4d3ae1ec657589ef672d191bc6b178f398e", + "ef8546064537ddd89f18e19cbad10bb6b06979382fd16f3879ec39de6942731d", + "7684b54b25bc614d2227365db75fca33f396372b6533bdffa73cd7666fa9b9fa", + "c2b82ac97473349d3c711eb25e77c58403aaee870c355c5c91e804b0cbe737ed", + "066ad4529a4f0320772eeb0c616e8f24cf5305e25dae875279e46b02f6bdcf26", + "b5bb4a09729f97e1cc610f19b9f8d323fb9e7066893f4ad5c35c879e05ad8388", + "ae3e02ce1ff0f83e5a5363f3c0d6140e5468a61a11726348978d0f53ccc0d895", + "767337cef3327299730883bbe4b798a2fa6488e1e57db548540d531add6b8e31", + "7b547f7522578d1d78193e3e28addb3d1cf32c08c5a0414d2d9fa334d9b6dc3e", + "d426ce29e75608ff794569ecda68429821eaf76606f35566a49e8cdaedaaf1cd", + "502067f30649eaa2a70da1433ff7319a60f0c1526d631bddfa5d73bacda112dc", + "39b529b9f6831d9163f1ca5abb8163dce19a3b4372b4e83d19d65f5cdb0258f3", + "3bce503fac1b56484a2b941c9daeaab690a185f7d6f6a8647ffeb3b74c5c9c96", + "2325157f304c0bb3afe17e50dc96e1a39b7064e108ffe115ab20da1ca20124be", + "363f6028b1fa244fd79104ea36b38815b9ce75222e369cc1d4eb56d86e37a12f", + "bfeac832d4cca25b3ab8be9a4d5f3ee48e4d059e3a0fb905b35987d3cc1f0c6f", + "5bffd5df421893bf2295f99681fe5bb6eb73bd12c500bdb4fa550d821ed49f57", + "39d3bf44cae6137b80335658d176d7c40147893e1850c832469d4a374303064d", + "bba4a221270c4f4a1de2b01d3d5849042f33b261af06eb1d1c9c5774eab35dfe", + "6c78e02146800ba9208886eb7cf229b775bdae0b9102e6e2aa1ce75aee5e0eaa", + "9621523ac9b5d30133b99f2902d03554940eed4cae65dc30dbc1bc3ded84e3cc", + "31d66faf4be7644343dba8525235fd472a2f61e35652075be261b8be135e8cc2", + "a4883063652637579f2e17b6291c2e745ebe200ecc8484973e21d09fbc2c37ea", + "f24e384790e5e1b5e2519fe59b633b210f3ad5d8fe31ddf983e3e56c96928db5", + "78b3696e777313da97f956dbb7d402622998e6145afd16edcfcce042ecad2238", + "754862e57512ab1520992120e0e4775b3b031e6b3cb5b0a87ab4d5fd2003fd40", + "57b67f65fe238e41ecca201c3edaeb230097dcc87d522c778d4898d412f3047e", + "1f6c8867065c19ffb9d9cd078112be166cc9e7b92570dbd88e748adb71bc100f", + "adee9d9b535bc7811144943a97cd6c1adc56e317f8e4c30d92ecc94e0103cbaa", + "a38a01e26c5efb1a9dffb8632430b7519daf139ff3533829f8cf3c347e364bc8", + "e6480cb2a9252457172f0d7f0d70a5cfa2b886df771b623f3cebbc2583eed279", + "f1fe9cbcf22c7484feb21cf8b6fbdb8a7036958af9d808f3aadff41626ed89cf", + "baadcc6133daa0fb043fd9d65785466ea53a506809cd3db4a7845426dfdc16e1", + "238a5d4d2c06abf6facca894daea99a4d543ab384a7d8310b6e7ff8f1c4646cd", + "3f99bce86f6fa3d946feb6e7cf96c348b2fb19121030a3694b26abbc4ff41b6c", + "737ffd9f8a5d9ec0a4779c4a62a39a3be34b330477bfa35e8137524c40619d48", + "6b785e7f91e33aff48b1fb38172c717b0b7860f7ab2f3a55486c9db40e8f36aa", + "3190f77d77783fbf51808bfb504116869816d43a372b86ee8e96354b13fac1b2", + "d21496cf54576144797324d1378ec4043f55360122f354c2e396362760eeeda3", + "48372a50ad853bb56bafe41ef60a5c10815660e6aba67afc74e6556dd70b7716", + "a0d53cda87049cf778d9c74cf84694ecaee51ebcc229e1efdf29e85ee31dedbb", + "fb2e7c5173148b9076eaa0b3b880a559e75b30b3509fbc5c345d00c50915c79b", + "1a1919f653da43af225dabb8a3e855521769aa963ed3c1803067740b74a676db", + "27fee21fe7522184c3ba02c8d72c4161d63c48cc053e1f05300685437582f0b9", + "a123583934935665e2d8c4f97b04e2480a8b8543634403e90f276e1dcc1143c2", + "7191d7788ab2b6b94063c206b7afcab411528bea671c57ca6de1215ffe8d7c18", + "4d9437d3126fae0d4daa7416a31fdcf3a5ff61255c435d0790f9a6f118c7acfb", + "cb34352156d9589443f385ba0be18671adef0f45cefe02b5b98d1b73d98f4c40", + "c329bd9d1bcf4a6d1199304286571aa0d60d9dad41b1033fee29d45029ece11f", + "f2f63aea5dfefc37d5ffaba2e4407d6fe819fd419e313a2069f70385389ec5a8", + "99b7e03d113a730876871be9f955410bde97164f322cb6e193990e8ff93eff7a", + "8b91092df5c39e39599634be4739a575e49474a4af16ed78760f1839ace405a1", + "cb99cd9490adeded7e88357122f93d607d0a00dd92c355e0914abc32f0dd0e2b", + "e991b9f06429482946b5f2f064652e229c744ae78359a2fd7a043868a31963ef", + "4302140f21099e4e89f8185a5cb34e760cb658d44d8c42657de07c4666e60b86", + "92fc42b544b4fba400057197f396d991f026f173931dc8ca92f654cf8fb40b2c", + "16214c82192475e343fad4efda5b44ec6418273db775a539c03f8bfee4ddbe9d", + "45585552d946e61043c1745cdd58b4e17543b371f938046d49ac0d4cc62b1115", + "1695dea7482f45fad1b5132f98dca5178d3374b4026f85ccd12be4d2fdac8a55", + "a0e3c58629dd3229422cff6ae42105d627795c242c44a5d4426c8f6ed046bc47", + "429408f7bfa73d21f29c73dfaa8f083880e5a51e16a8b8c743cc6b34371b36e7", + "9388c0003535d192a992044fce1049be87f2b34d4bf7c18361835d4ed583f7f6", + "28617d3ba0f9be531bf62e04cc001966d6bc4d2b70ae2944d10bc13d5c72b3e3", + "691796249de0d39d25bed4c435ab9cdd35e8abc58d1d1f60c08d7304939df0d8", + "0532ea04763d02bcb89818591cf61bd83c7e98778305797329722ebf997e8db7", + "f3593788c41b13e1f146866a01de1b62101ef4dcd74523cc061cd3304b2fd234", + "46f026706a2f5fbd080198e494c9a4da6d55fb17e22089864f4865fbcec1716d", + "3605cbec3962e20421de3904643a59994fed85b67efcbaf80c7652dbb95eb2f8", + "511ad81df55b0275e14c2af06b94beb4aec60b7e5588ae2dbd348122b2f6c452", + "3d8781c923a55863bf0325be97f1a8f0396be0572ce0407c4278f6582acd5d75", + "5329452eae1b3d6706d6307c2eca23a96d12b3631dc6c235062bd95e23ec9f93", + "d3fbb7ff4b61a31eeb2ed6dbd6cde67c569ecb23072d52c35f0f295f3da54df4", + "a252c306884c99c5ce2003063fc3f1618584339409ba15cbfbac19c8bed9df71", + "ee868aba6aaf070e53c908980a7c186e78c1c3afe6409bb7aea05cc4cfae97d9", + "1c6fcacb547fefc2fcc0859778a6c44754e6c15714ac2a28402f4feea3494a1f", + "0a27aa68ec8aa0e7b5d2ee118f153054e357f89d8e3adb56d45b8bda5ea6846b", + "2e42832ad90126b139553dd31a7b8efd6ab52c408358df4c3fc608546cc51b28", + "1ee89fe91aa04f63e074fc6be89a1da961eaa0ac7f1db3a56c8f1e3e557212ba", + "166a01d62d6506036d3e770357b0813ad51cf00c7d134c13fc13e13d0ccb5c60", + "c7192c57b8ac8b999a66db1f1be1ceeba1752f01be3051106025bfb01ff4b260", + "ba992732b183ada7369044cfc931805e89700279892cecd9a394052928a7f2bf", + "60991fa7cc1f34b96e6caa26030cbc14cd47301521d3962bacc7d5e9cc360d07", + "2c26c2c8c686d37114e13d1b713dfcbcbf915df67ce6642863f74138bf124d34", + "f933e1e1611bd599243a30c2de5d829c8656b7b3b2cac027981603de55ccb0d9", + "d4a19f898ed846b8013a997a20dbe8dcb3e407e39921efa026833a411d0be7de", + "ca786d425bd90a11dc9304b5765649498500237d5213f33a610fd500c1ab88c2", + "71dbe7d2c4185e385f2a0f656578ea068fb9b8890b4e67ed77af1b8bbc8ec36a", + "e50ce86ed0e5c5d2b330a0e254dc3bd27d637cfb18520e62d4323d1fe42225e4", + "c14dc82dfe12f1b248c84d33c3852071bd0607e555b6a88bd4be0ff60b629995", + "e78cd42468ab76cf6cd7b473c6baebffabf4396a0a5ebfd9e6999cc166799f74", + "13b84b5e904e85745d417646b95058b035877c3ec571484ebb8f7c1ea0ab7fdf", + "1e069a21a98de55d3fe1b4f2863bfdbce16e6f8434d2d32fcf43bbef876c1a19", + "1e6477761a722c473c7860f1a9915303351057f43315469179510f570b94935b", + "a8d7f2aac79207bde9b2047bed7d51be952152a9972a698d5db7c1d060b4d7b7", + "4737c407e94d62ac9ab72b1d6936af3245c3935248d7fc5cd6e638c94bb25418", + "0cd453e05b646f71847910d8a10fdb6837b4a11b100794250caad5c1457531e7", + "615794ea24979c41aad91886857a5e5b998722d9d83550fede11ddd7117c1061", + "ba2fbfe4496d49fb93a3ae771ae8471d4bd402ad7ecab0c364d65471ef6c93fa", + "78a5204a86afa2548962620a804c8afb21991bdb0956207e87f61eede11e2450", + "669a93399ae12efe3eb287c4c09bb092bb059f56010028b3b880722c13e1d220", + "928d792670ccdbf9940e3dc9ff905cffa71c10c642d7620030d81b6c7dbc4213", + "4f06e04a723f33170f1c94f6b376991c293ec06b463a370e188961aae894e524", + "5ce6d5034ee042f34972709bfb78ebd316889e314c23b3347d1b3c1ac15a590c", + "07ca36cedd3c18634aef691cd6dff9d488effc7870344e02e6225ec319792bcc", + "1f9540d18c1a1a1211cbf9e7774e20de210572843b86f617401540a8e0716dea", + "5ee0b189d8ebff6401f48413ac1f9be74762cc1ce3f8611a112407b24fa54b6e", + "b50fbbfac75ec5a68ea029bd3e24378530c51f7e3349badee7c7f56c5698b5ab", + "016f0170160fcea6a26e8e502a58e4857af1a311949f015446c1b2b3456ae418", + "6500c01d9c3f7faf77783cf136be26a176a5aa075b0c2ab95bb95a85a7becece", + "95deffb239c1667ea8ab6e20e2d8a517100548da89b4c4636d7afa7c3c59408b", + "8f868821ec721dd1e0fba1c54b773c42d45ed1e37110bd8a67b04e714e69f500", + "a813f6499d61d26fa9211b633783885df26b0c58b289b43e99856f12920205e8", + "e12b96d8d429133ed94a5dbb034d6f9db6cad26eae49b7c2a79a6c38bf552b76", + "2f16db282916e80a279fc95585a958395653ec655b172a7ca0afa1084b7015bd", + "c8ab1bc3fb8af842b540d77d9b008f835ead1ad0776c82eea2b19ceccddf4ec2", + "b32937eda898c27ff6f11f515f15221e2458bc2187b78c811b69539169235648", + "6df124ecc49bf37f8410ee7bb9637f0edaa0ee5053b38aa6c4a3debfd2da6c4b", + "e3c06c782be3a577dd8ba09d310b93cdfe8d1007947d60476b0baa2c019b0d09", + "2dd71a565d25fb3d1f79446d2a7ee4125e54a7aa3fd490b31ab74186d6d33c0b", + "606b36a7aac9343b4e7b9fd2bca21cf27a287ae66120175dd0e2e147b70ce74d", + "736d194fe7ae94a77cf2ed1498d72e5b139e3182860c940846f002675d1cf470", + "80329d847aa70d8d66ca0e2ba806568cbbfe4864d3688fbf87f9adc2720dd9b1", + "b80236d850e1f809e5947f5fc4801762edc92abe784356022b74f8338e4c8885", + "40a08f6754089f97e90a7414a7d601a1b1dd7b529b920f1e74741017c34f760b", + "f9316db80fc98393f5d8b55f907306952a57d5d81d70d26147d743a88c261b0d", + "e70ac5c0284d8530c826cf5ee2fe2f3f299223362e55ea9d83a52a680aa83cfb", + "57ef776939c3654b2eff622c364541ff6a5c1a6f51bd4a4ff8053918c4a947b5", + "7f6346ca1341a77ef8ec0e7c254e83d2ac2df5d5721200cc0c4bc0c9760be751", + "2b33bb6156689b9e3bee9c547a7ba26ebc96878aa400c7999773bc917112d654", + "4876f871d542da6ceaf13de543fe57329fb78aa95fc39da9a49b745776865496", + "baba8d7e1ecf3b431dda0f0cd162b983add569a86b0e165fbfe06e521c535d93", + "4c7ed9e3462f2186aff677c0a4ede9a79a11bb3b4fa92dbd1b3e091da87a4e97", + "27af68806eded7b33a22d4a56cbe5a3d01259dea64647c2d424a3e6d10a8ba4a", + "db457e5dc4647255513c2d4505c56658dbb581c2a84b774f119f624179500e7f", + "a5d0f6bcfe584f9dfc6b87e2e6e91d32b6e7b0b2ef30dfe4e83bd2b3700fd287", + "85b49f63d04f928fd8f44d173906af24881b4a65585f7bb8c811668805b3f224", + "91f4f1beba636e2c8aa0a4998d47405f3a7a4fb1381f4225e6b4513decdc4d10", + "0fd8a0d170f5a4f27becd5b57b04426d0e8f06fba1a83c4a0446dcf87eb92f61", + "1e3a5ba20ff90b9e19c715f1d9d48a168f959a45fca692383dac5f62043edecd", + "9e5b0a48da95312bbae96d2e0b195b168e0a01f66474d1c07476622f0e28b8d0", + "c226b444dd99588f500c78187ea3fa972714ae5164b1112496fe446a1f2f76e8", + "a6763a4ec6f88ac4db3f4f58dda1f0ca34bd2f16ef692f54b436ea14e4a70bb4", + "b9c9b66f958b4948e78e7dd7ca6dcfd41425bc4da2d93d3e7e87abddb619436f", + "621d7b9785cb44539d6e4686038dbc82749aea187fac6f1eeee78d680f9746e7", + "efb34e98e55d9b1285065dec367dfa1132184eac6ba1324606f3ceea2e98946b", + "86d1797e6a3d0a2b6d570c623f75821ff6b2effbce66e85db7d79e2076c709ee", + "f7f147b80b19908c3284c0cc0e537e2dd7389357b6f820d1b78aac0554a4c6be", + "267314398d370a0b3cda233a584d11a5e376fe37b0367a5a573bdac2764725f4", + "4e826460ead1ccfb18c478f0793363e8c185bcc4a492994bd6974eaa75938fec", + "ec36796c607b0c6d22f9f9e451f50c46140933d216b6223c3150c32fdf325d38", + "8374592cc534a09fdd1f13b51f2f5c01bd3f22c13e831e6780363e200396c96f", + "36c875bb639f705dac2550600f132e695254c865fdaefa5d70620fed1ddccc52", + "aff159a81809e35b92ebde8be589e8651a789b60db65fe819465c95ad2198123", + "fba0f83621aae9ec6d749e63bbb0dd997b5b9fa68ce124d4cbac6960df6f637f", + "fac6df4cfff715d4ca38a3e5c81e395b1dda87a127407fbbd2901837d0ec63af", + "8cef7c600f78239abebf2b3205ef828ff5c01413d64cae2d3a7d1e2ed1e3718d", + "735e95c98a554e2d6f8266350db31e3ec22b952ca20d635c38ad47af3669a940", + "c599a3e5118019481d7c6328f14b8be3a8a51c96bf6e633a02eb3bb0e0461ffb", + "9a9f1e2bea5a5c1d55875f186376408dcc29461538e3d289369e93a1ab2ec9ea", + "d6c93171bc398fcdcfef39d6ff7e4de209ae193db36f006b87416040136437b0", + "4e05b5addc7c0a373740698a91031358f2323d7084241fe2474dd614b6bc5a0b", + "339c871f19216054372f348e9e3a9d49b1c98c60ef2b1e3a5f6471b94c2fd3b6", + "f44a97ede630654f5aff640e786062a3d735993d212e0c9da1c2ba1bdfc88265", + "d43a94a104c346c511a0a5f2d60632f442f68489873530dcc9eb1ef06882266c", + "164480bc9f8e73cab97d0fdf53b7a65fba059a1df3333abe5b689a4444959939", + "1b6658093823b88828268c503812220e2ea6cc90de3b2b68c93c262a2fb50c18", + "17ad46d885292a5bccf5530ab0ac2e060911a7a67336ec2d154398fd7453eef9", + "c276f44523bee7649950b3cb41ca69dd3064622b55996ce754ae62edb699432c", + "ae5d1f14dd4847135baaba60e0ac810b4dfd3f5b8468d51ab30c72b2393f9d84", + "79d2fd8fba3096077f98eaab4021352ed70486937f26784af607b9650e12bea9", + "18ba34457f8c67eb50a1b19a05bd8e5082663dc507b69d8fdf4aedcd4903e4eb", + "3f4aef4f8a65440eb17121bee85c50a5e2c112cd4d3b770db235bba7cd20214b", + "27f071bf112b2f57e36f6a8d859a7cf41e4903b085b5f676eb1b00f6009766e1", + "21e509a0852a651150ba50f2d94c95cdc344fc782853de33b44a0df34c815bd3", + "cd34933dc68657391e423d997a0ba930654ec8920f0d3698f4f16a08b1786add", + "5e0901d6447edf7f553f919238d76f759ecf808eca3d8102ce5a126910ca2709", + "26ea9e604857fad82d45e9aef54b601f3129002a15f71eb21134120d3b314b14", + "a14bdfa6d987681c5b3089eaf71559ffa45967614b5b4d1c68b34e78d342e033", + "06820fe8c5cf6e90a4d6b0d07dc5b091801d0fa182d1cec9ad21c59cc8a4bfa1", + "ec679a434ab08c87e81aef9b06735c73656e4b2a057b61892014c6b3486801a6", + "47cbf391792a7fd74db76a491f81d276c7c94d9310721c7314bf425012b88e7c", + "e11892c56876f05e849f3e6e1f20347dc1055f3c4e2ae5d9d79da73961d49d8d", + "070eb3b26edf503c44d55d28533d8e697573db75774045bc06986bab628c71e6", + "d6b34dd28981b72ec0e958775f75ec192b9c8a86b3d80e941f65b0793dd5e9b5", + "db46e799d20ea3cdf8948b46154cb5031f6cf97c8a70ddf180b14e58e26368df", + "c60330a6e3a503eb1a55d3df9247dddfdb243204686975cd3b6f7226f0d922e6", + "a436011d2c2b674e86e73dae49d6d82ca7251e80cbd247c052294cec8330483f", + "a630f680471fd55b0185efbae0d94854da53763d4f316c3135aa1beb3a5670ee", + "10fdfb0a3bbf4d1b16d4eca38ff4a60ee7ce052b9acfbfdedb16ecb2cd36d0bb", + "8d6fcc73959de5ee22bbd7436f66ab9b0b5875d6c50ae928d3903a4fc2a1f2e2", + "851a9fddbfa04a58553881e03a639634384208d5adec3b6e01b53b5fc2653ccf", + "eeee358e5c3ec9a23b7bbc79e0a1ba8dbc7bdf343c6e75f0022c1bf547d84602", + "64b31c6238768b5410cf237c56f0a060f6f71fe349e2d6bd6e334746c968abc0", + "23cfd475f51d43f173375d46603fca470a8a93f25d906c215baf43a0173d2d71", + "214248dfe4ec1343eb39808f28946593267521e5c49a4373ec4cfc55143209c0", + "5b55a2cd5b747a342b4e88b6a0d6b3dead7fca0e4cf6ca2a63cadae96f32b107", + "b5a47fac066a1db34e1464f0c1b1ccc7792b9c3f8efd17aac6a1a40822e52248", + "eb906e2d904cdb7771e19aef9252cc5c6e87460d13dd6be81873408a4119ca6b", + "422efa1432030c26af36daab029236500ceb2e268be91361a23ddb35ca478227", + "b524ab91b53a08e803188ca0f40bb9bc7af27bfac63f4459dc6754444acf1542", + "8e5b34a0a1ac29fe837722db37f9789bcc27328c7f08889d58bbb9a9e92ba9df", + "70a2ceb119527bdf331465145b4e8bb45e28cdb90469ad731fb1eba9dd57d418", + "32bf76830929bb632717fe0f9b600a3ecc8d1a7e2e250b53c071ca1bc96521ee", + "1c145fba3b88c8f8767acb383cb59887cdda5c60eeacef0a6937757041068a2f", + "99c99601c5d87592b42c1f5310ae0161c589d22d03423a7cf4e9bd0b844342da", + "c13e4862bd5ad06934069f75dcd0a635bcbff6d15c624cbbea774b67bc8f5fc1", + "9b4b794243e7db61d624e0a50f429df16ce91d2fb0f89bba752d7d060c70159f", + "4370f4261c3e9373112257f8575ce31c520a4a360067176d28dce51f365f96f5", + "0a494da095dff542cafdb39d0e8fe5455c598bff222935fd67e32434ceb1a9ee", + "4a86343d8ff03ee1d24878f4b9e15ae1b78892cce2f15b43ceab82e4447f6696", + "ab476bac044325c7039327f88a2f6ec2cb297b8967a8a328588243b86a665a39", + "4ec9bc7117aa3c2f68d224a6730d1a6636fd45c6ed32db3ed306dd14e93671ce", + "d83b2b4d3f5a66f5307a422b74d83bcbfb219e928def4af44d9384e6f34c323e", + "2483b39cd6038268f97942658ac5d3f7c84a3045a951fa163d1690ca3498efc2", + "e4c64229d62175b48d69267691db8d50d1e3953b2d43478ba4bc990629d725a9", + "756d9da13cdeea159fd60a58bd7f3ee44d8342e84bc4a68ec8c3767b479629c1", + "cdab72a50172ac01df64eb300a77a300d857659f7a0afc5a014b4bffb5fe7b62", + "8ee9514fe3ef0c757d18a8608c17ff8be889db4da497eb765e0a3585b760c10d", + "584d3d494aeae4d5e48131db03148048db172195ac25788706422301b3e1ad45", + "e84296385575a118acc07e395393d98701ec89808c7e07cb3dae0d0fe0aa0e64", + "ea8df5eef8c8dcc84bd2998c16ef044062f6cd0730578466a0b0aed7308b8a7b", + "107261962ae3bf43b814d4355f0f5ca4ab0bb4b86ec995cc33e6f67becabdbf1", + "cace5aaa2a426751a05fd449bd5d2d810767146eaa8b884d9a5a135350dfcb59", + "18eb07f11309bb60b2dd3a168beba2aaa816911983d9b313ecb6446c11ccd5ed", + "da95d9212366492074b02ccf22bdaa44fd1211f4f3798760e7007d24ad9c9ff7", + "fcd526cb15379b838dca082d23aee477b48b8a3308454b4e6ec61b2f448f3035", + "696725b7ca3a2f8b7a48cfc2aad0e7b2865088e1eab767893a8ab4afa2b03278", + "8dfb0bd4e89e49c27e9c522a8c1f7091bebfa3818efb9375f321320a40e3060e", + "e2e0183f71fb66b739915e99952d057f13bbcb6c3edb63649be2750f48a1f927", + "6576c5903530986ad9855271e304d76adaa134c2377eb560bf7bb72f6231c2d5", + "2615ff64d72b954164b7f21e3643b8d6b7e1d31f2347ca350c37169282d436a1", + "64f8a866e211b544d5b0c6d8dbef8e8c097a0385be16a5fd6c0d39c7e00363e4", + "d0094abd34de5f2ea1e7e3bd5f7cf42670cbb7611da9477502ae1a791418e687", + "43a633ea7d3bede907da8e18c80dcc0062a5ff395e55bc205d3d0b5351dca639", + "c2ebcb5790cdb1a2b35226d4246f42e65d4e1ad572f5b0f4e83276d9aecb23bc", + "449b3ab8631c849a1f500b5481b9ee4280b35c9ffff8fcefbeb5845c6d94f293", + "e34f0e06d8a4bd4d518479c60ee8517f3c2f99b00f9768c8ae4e6632ff41c29d", + "f6aeb9d02d7b61036d64ad0751ec55345175f1cfd32c9e5b3d25d827b30adf49", + "95dab89bb3267c2f2e7cb43eb2947506f5bb2e8a25cd9f1aaf999f1b80a635c6", + "2e6e0b67439f843f40fc84890cb34e9db6c4a8f0c191517c399b2ca01efa9a21", + "0878b08d41a5a491637170925850dee51925f89c67a8d21d70e1e4361592e2a0", + "6eeb48415bdf8902aed97bb557a143dc08844de1f899adb89b407a0d9f9cddd5", + "e41965ee7c19de2c452282e2195006e6b5e07853df6e1af7f02b107c378a19e4", + "55491381ad4a4ba5fa68242ddcaee17078c42acdce2bf0832cc63174d3f7cfaa", + "e4271db4daade501838bf25e974d3f9535a5940c4a09e0391ddb8ae25c414ed2", + "1500c24a00a38641028bb991fee9ddb4431ab06ec6b7255ed9f313f2d417a737", + "d78d81b17bbfb0cd35d135dccea29690fea885fc538a9549042227913141958d", + "e6f3e89ce1fdee07cd46882b1820db1d72f58f60d5177be7bcda11f536690e26", + "0372c0a14bf3c21ac31846fcd363b7040c9c66adf886dc5432bd76fc8d9f637a", + "6478922a12a92b2f5e2d1333364e164cfd4473bbb5f8304bc0f8225cf7b5063a", + "3882249aa3ae63e32b14c262eba92ab3e138aa723ebfa2a420d86e4d1e7e5ff8", + "6fd946c31da6ceacca1c7e921db28765dab91691a3ba6812cd5a7ad1ab89f40e", + "74759c34542b7ae1469df5f320466c8430c2d5e6a671dc321e0009f12864a077", + "4e779e0c2a1fc25701d1f6156429a6e5233f6f18b971f68acdfb789ef615b6c9", + "3d375a367990851b82209fb3e3d24bc73cda662f7cbe158c7005f0d8401d21e8", + "dd3d8ef15221568e7d53948767762e2019617addf18a4d1e4719de74fbd2e119", + "a68cf4f82be5dfa67ab82939aa3b224fae382219309fd16405fe0e8350c1d809", + "46c19b526056bf0159a9d72544c60186e02255d4f486e51fa8bcc9ec9126bde7", + "8484a0a8e4beb643e5f23eb44b42baa3d19e679b804b7eb9bb2aa752a0534190", + "367c82c606e71cf13569cc1c60660f4de0529c8a76f6ae9bdbaeaf2bd2ceb335", + "6c1a04509395c13297f1091ecc97193b7fe97d02213a6c9c23da5f76138c6249", + "4e01ab05271524a0d4b4f7687288a248b5f89b4fec9897654b5be1e70d1d8ad1", + "408cf4f0df43e8155fae53e3c34f639f3b59fb77269a89e235c5fd93d9a1149b", + "b2c5c3ae286652d0abdeeed83e65d6d589aabfb06d9618af9e1bb2f23764cbf7", + "84f537b803e0d8b1625a4c116c900772988df159aa2f79978a78515a8c9ee20c", + "812e95e93c5ef9ea48858cac964a75d63e4bde79d6ab07ed63e1f289bd5d6408", + "8c130ee4e6e40fb7c6b682aec64bd9ab54433b283a0f17e931887eb1889141bb", + "9cb8c70ce18f832d9fda576a8be43b3b719a4527b5448e2922035d13ede02285", + "3f1205ba55ac20016ef3d88cdbd63dd1556d950401090f4e49f14d2a63302f6d", + "b92c7d9103e38c461c83d60e88f54d382e322c17d93a26f90fb911d5d2ccaf1f", + "12c40beba84365444adf0cdc34974df8cbec873a816aee0426298059f934e2d1", + "d4d2403e6e34cfb3ea636ecb602b0c65df3261d21a5e0b25086f0936a39f11df", + "6fe8ff9b723c0d080197556b3c8217d57ea47d771ac10f8e541d29a625ff76fc", + "07540101bfd2bbae69b7a38f00d81c1fa7baf7ed500b63ce4572931225311d19", + "e81f509000e376fa3f1c06ace1437c63698aae5f4558154d2c547363e1b7109a", + "fde065a64dd1aa0862d998f46d082e06c081db89d140bf20b96c82b437a7574d", + "e6fc051c0ea77277519ef85223cc9976d258e5bde83ffcf3f8d8d91be37b2fe5", + "218f197b77b3c303593f0198efd9af8471f9460eb59f8a857bb2f3ae7345772c", + "5dba0f2c5bc34775b44d9f6e6b57a5dab4ecc84108e6ba7825f4af60d66abe0b", + "27b212fb458838bb77b89b8ba4e3783f3899c580195dc8f39283142a387486a3", + "0777502f98b6ab857d569a115ff53dedd7cc2119a07bdb27d677ba5531c41b2c", + "d9d0baacaea542ee775f05f41f3a5f1d89a4d9df7c608ec18c030a543e34df99", + "fd94b7e58a440a0af9b9aef475edaffec10de62864410487a0a78e45195886c2", + "ef88b9668370b5e51b7ac89f9419c03246ce4a5b4334c18346bf74f374f65878", + "e58074dd09005b89e2d63d2f2fdd5e3638b34695a76055c3845ef9eedea76a81", + "b23dc4eedf4d129a37b49efa5ec011aa117778126dad60ca8d5dd34e47e920d5", + "0c7bfb6a36163fd51cfd21a926332fcb8fc8e8d9c78a412a948f57861ad33717", + "55186223a40b3adb9fdf805a71d1b07c9a6066138f575274efd20850b5011385", + "6954e5f6d1213c8a62a65a179c12c9134f0109c6378906fe30238a1882de877a", + "df63b51d29dc2763f616d4f151f4fb45261dde2dd0e156af6d949fa5be754629", + "3f97c095153f2cc0a66b5402e3a1bdb2738bbcffe4213c204216840a8c2ea2cc", + "714b809bb1b0ee99acaac2a0c917e2e50a4467d71b06b30bdc97c3efa41e86fb", + "32fe7ff158a1aa4ef830593115830f9b9a3036ecc0f46db581b50d3478cfc3df", + "f42b66c64f4d0f7ba9c691c5bb46af935ac8884fbe379bd10cc47b2d9f2b0bda", + "ab6e13a52fe9d6ab3d06629074220dd123ddcf50ccb4289b2b99dc8211fc8f78", + "b771d2e94818282daa2f8cc848f79d0a3dc3245b9329d40ae2fd7c4c03fc5a84", + "97325092cf84d840f30756721e1919769c8d7d054a7ab0cc8ed15fe6e2b0031e", + "5abd8b6d52552078b0e4047625c0d022212fcda6438c337563e22cf337ca37f1", + "033d1fb36765974cfce9f154b21dbf4e440cad78679b39cf76aa94643e31e13f", + "d194a4ad5e0fca082d8f37d0f2f39030580a3453d4ab3f662495b799dee0384f", + "edbbca8423aab3d450cd1068f73f217b538dfedb23611df15bc803cd7d397240", + "6d231d55aa6406df957a1ab97ddabddc2d6e3ff53a41fd29f3fe6220383d9622", + "74749384ced199a4f5a58686abb7f45c5c591a7a2122d04ca0daa181f51b6ab1", + "9d454e741ff3ad29ad2645a93ad33ea8b5932743f1d6a6a30516e84b684f2ca5", + "8a93565a149a1bee3e7e22387b32f5de1cac7fc70feebcbf9b3630ea6d455ee1", + "cc2b0ecc90aa6dd4bd0d5f9a97db3a00c5a419b92c84ae50dc56a82aa41cabc7", + "62186ad2f27fc1b5fdac666f45c4176aa985be61e55c326f66041fdb9256f042", + "1d9ccffdcbf8ee18f7f58456bfe5bf92dda43de24f16af05ad160efd19285ce8", + "c9c3e9c35a214d36b75bb5785d05b053d6f15869e07ca3813d41d88603ab9082", + "521a12a336d333191d45b723aec23403dd7c0fdf593a1c0339e683c09746ebba", + "7a6a2dfe526ae60cba758a122ca2e29c32d0810aa9b492be1f3f9b70407b680e", + "04184a0144358cf84e47f8582ca5592c6ac430055c0935d1029ec7c404433758", + "c52ea8cd7aa5ad69f4a534ca8e62df8b2d8b187b506d33ceb4fa60e6c96863ce", + "b5620020c56aad80b9c2760f3595b81c38f1267492e912c6ee9c08ba9f3a8c46", + "2347684e78914de8cc62060a4f7ce66f66d76a2e1edd338ac9520d70346c3f5b", + "e2df784a99f5ed065cd5c4bbfe7e4a261c5a1b4086fe4546f95c4fa8befbfa5c", + "cddadae50544c763a139a99b28b22a82122d9aaf81bc3171be1b56e487a2d1c1", + "712eaa408e45b7cc47cf1aad4619c06b7955335ec6e39cd86f4e8548c72088e8", + "81a598e0289826891924e247204f94500b29bc15ec45016bc6928884c507f0cc", + "55f7490266422afd64dc931b3e2dc1d674909113c085887c00e7b067073a5c6b", + "cdff81da2c027fe2e4088b34a529f8505a723c72b3fbf02f87016951efc0c730", + "2c5bb8189d069b667f558938d0a5aaed7ab75e136bdbbed76b124272965704aa", + "aa90efc23e5b98643360d886ed1bcfbc1588723d18e5372333898e7138578edf", + "5692298a6433a77c275375a45c3070cc8cc8051ec745e6af82fbb40051ad86fc", + "e9d28373a640a818793cf6fbcf84af726ff2a0c2db8106fdfbc9fb54a691caa4", + "8559566391e8de6d23a0031c3721fe7b87946f64b2242746fbfbfc627de2a652", + "4fc27c6d5d6edf7aefcefa0c402ed64e26a1b6e18675071d9641c4b92a4a39d9", + "e769b969b4b122760bc82a4015d1153f4a6ab247d2ff6a85e30c1a8d7cee5bc3", + "370447ceeccf17192c639f50634defd1460c580770526c2c8161b7065961e813", + "377fee8a021cea17e109c5331df9788dd30c9e6c4f8e4622d0a362ff6666fd83", + "0c21bfb8871c0a20dc316de5964e3f0c9ca01190e3e73eef025e4e49a3bec59d", + "fb8bac53ea5e84a9388b8adc290487ed7b95a57e165f4577a0c23ca9692d2021", + "7138fb219128ba5d8466d190f51e11a62ef8249536bd9c7c14260b7b6333cc2e", + "608ff84dc0933bebd7c0e923e9dbcb4290bd6a3bcf8f5b30313d99a8602f794e", + "7ec5c5634d8741887c30e00dca172d26dfc642cfb711bccceb7608e3154c2345", + "79dc96499ac622568be5d51f8d1256c6b66b8c83d4fdd78acb991bbef7d5108f", + "8910685a75f6c453fbcf077ad67017fe6e0f670e3111ad895d5d0cfcdaea8afc", + "0e159b22a99db6fda6d155898c7a2b28b9c5fadcc8feabe0fc351adc9ed87bf0", + "81c003ebc027d131b71f42dde213e828f139c3abb820ed732bbdfdddb97afdbb", + "3a1c01f7bd242037f8f190d524714eb55f0e6c270c2aa0c2afe3ff359cc05ef1", + "3d5ed355c31e887756fdbc5d9858793e8c7822311483cd40e8a749f4ef519b45", + "b4bd1f56c4ab0d585a605a36849f97c901ee9a3aa006a850ec08d6ce348faea8", + "4b07042b5be3556e66c8c7d32cdb9a9461eebe872f82c273e5f92d2ebc968c7d", + "a8d1f62724fe1dc85e90581684199a6f7957b2120f8e44b273fcdd9deaf68f44", + "6d5938bd01eb46550119dd793aaf2873f98b538a258b862cf3b4baca517f7597", + "c11a98b68b391ee8afe70c19790606720668687e05f1d0b6853e7b825e19368e", + "0633ca7ec13ee9cdfdf9857850584bbc4c25614790f1894887787bb4bc22c02c", + "06eaff5db486220809885d0f1068cf01cd08f94c3644a10ba17418f89db6ac95", + "39bd866acacdba5e952f7cb1851761b72bc39060939d8f2479aa4d090471d74d", + "1ca6ca9339f7dd1f8c0c2ff1e9fef505c1e4faf42da47cf2a2eed778c20a686b", + "6c63bcbfda6c96c35fbc8e84d0e9e31aeaaa32a87f66d6d88cfe81dc31193f0b", + "bfbc47fc78442c481d18729a45abb681352541ce6e416c94cda410b751b6e082", + "e6cc5b860033b369e76b4dd74caa2f869b63bc1f92aa7685821028ad8ffd6f93", + "d45cb8f0030e228849f915023b3af2c5b7508be7113336743f7f1fa8df48db24", + "d9168a32a8f415eb78e146e7a7afd72e2a676edf64c55095c0b34bd2379b7825", + "ed8a8b8fea4c41dcbe9c29babfa61052d7b824e533c83aba250d874e423e60ad", + "fb5b854bad2263339417549c9a6b2235544bb2e0c77692043cdadc3deceaa86e", + "7076ead71a1f5aba5ccae66fa8c3eeaa2af96efccb4724bea74b809d98aca0a4", + "8f749f77e8709ed4964cc69a94fc2b171b923ca9ba805b128281d0d50fdd894d", + "398bf8e305f458cb90439e4c64583a2669cf696b9e012569d5d5f7fd0b705b90", + "47e6d1204976bc534844fd084638024783c67ae4930e5acf6c87a4a55e94d010", + "3706aca86246dd6de29df0907120ed95be97306fea6a255c02c06d02af53d5d3", + "4dda1923be8ac89231be5efcc2ec57e48c039a86ca3582799d102da9b53fd249", + "99d7da008390a2f05f292b3e0c119b70ad5aac0618b6c4c568921cb5fb2a25a1", + "b87dfd898be09ddcdc5fdd1668b3fdb075f088a28184ba20a25440f8d0f5e615", + "68f36deed7dc15e85ba081564004ed7e7e7afef07b15f2f84c5a2cd04f6bc789", + "0ffdcc3565c7b3d875a9a5af617ab8524ca599a2ddd3acb83718b125d039b8da", + "9f39fb10aa5d6655f391a358d387d37e620ca5bd9e5a3ade3a892792199246a0", + "a5ce7c3fa13cf6984ec968aac7e5df710adad107b09137dd4141f70ee34f49a7", + "10076fc5385df864117494fc878bfce6ac0b9e0c4123d1bb7b24ec61c5269744", + "338f713f422d8dc0108550d89ee710b4b27f833988fa410848035013c1f606a9", + "b44a3f14b4c220d5c00b97ea065d2fc11c02b5885870b414028a1f438e8c6fbc", + "42b44c502a9c6edcf639592a1a98cd00334db1efa7e34c44995dcc39dff9c62e", + "0841ed741c93f2fc2e404beb2ff2b487bca7f181181eeec91b1b53a621dcfd93", + "53a64218a7ca37fcfd5c64c914353d85cfa64d898c0eb500dd729d569427ab09", + "9bad7e23547ab6fecea8734316aebdbe7038306b5e3f6d7a079f21a6e60731fc", + "e8185ba9a76de0dffa6f57d5ab7f364bc52efb4a5adb4ebb8033f292bcff3874", + "91b6f925f0c948de44d807cf32aeafa4f8b3cb53739e9f08358df72aa4696a65", + "8ea3a7838ace548f1b2a7cc00d8dbe9448acb3291db5b80d726253f30c9cb39d", + "2b1c100f316a4369f138d8a418dee5a235c1b4aeeff178a04f7af7ec8a5f7ea8", + "bcd4a08122cebe7276e2f1138b3d9b726f74cd44fe4de54f5c6413dfcaa0c308", + "fc4d10ca921c84842ee066a77f34f6a201f0a9e81be5e3fee0d0cc1be27eef24", + "f1c54a98388d48c10b12dc0ee053bdbedff81ba90cb18e7b238a4aa88b4e4d6e", + "44608842372e35bcdc7c1df100c55a42b5ec1d882ece929da0df8630dcbf8ca7", + "e4ded72546f38061b8ce8decff8f5cfc0b104295561a8a9b15303dee26b6b4e2", + "9619ea05164d461f2744ae4cd68aec385d1eb7d80cc7c221474629e48b39c769", + "6cc01e0932f2dc27f2e6bb95e9d6c20de1be8c40c1ad17f83f9899a15d3cf195", + "0b01e6c2b9ec54a82ddcc1630c0aaff7ec74f148e46c7fa17945563debf4e3aa", + "2e3620fd6e251c0d15e70651ccf46a0b5d1a123187f8e3bfe112faa0bc7500c1", + "a4cf5258ae53c924dd36b54c4f1827c94d2a5f11885fc9016a29bd2de18aa555", + "51e2ac95b5c61dd8db313baa267ff7083a9a635c3eec3620aad40286e4fe68fb", + "b48a034ec4b404f1afb009e68e882e3b3dcf083b224cfff606f66feac0f54a79", + "2cfe2d8a3f01ae9f2424dca64476fdf681a66dd10522097f3fdc462c174846b5", + "562796f3ca354a09ecd3a3852436892d0b042eca500ed5e2d6e898a9e6bc0b95", + "513eaf453a61af9e09910cde55d81a5c689c6673b7611baa1ca1bf371deac70f", + "58d5c6b5f9471d648c29f0c4d09f35e3af3114e87309bf5a8d4c9cdaf32801c2", + "10690e0a1b3e5df7709d82d53b6c7a29a4f50452383d703425880e5b596b4381", + "4f4cbe24ca90cc178e4b072c20192e465367f2fd41b9055206d50adf5d5e299a", + "1da26af3c715bb8231056e2e318df61fe9e194f7ee738b4c8d33fd306ea1a466", + "a14fb97a922caf67316c8b52fa44ba3ad9788c7aa9ba487393a141325e2cbe21", + "5410cf8218e21f61acc4288d68f5cf244aa667605aeda09bc374af8ae93bb757", + "398f55e15bad4b98b4007c8c70d1ad0ec353aee7c878c8e8aaaafe4454c15c55", + "b78e7b4b4f118c2a734122472c23d062d03ac239272f965208e1e2e19fba655e", + "646b43b21ebf46003c4972531bace914bf0a6a037e22672388b6ebd9e1fc1e81", + "03a75bd8e2d714010633ae00289ca0591f4715d8819e28c16ce30cbe31f3a93d", + "a73c17be90729ba74055b373f4e4165259a57af6c35258d3c7a3ba2b7c8a6b8f", + "6fe87a44da00074d411d69c0f4c4070472ff8e00e7b4d15fdcd4a10575b6bcef", + "c526f4e4e4ea83505feaedfa92999722594cae10cecc48c5cc529e79ad39951f", + "8b6516805b6534720236fa144b2778e05edfa836996d198914a77f853d33b201", + "d76515a4fb74f45eb2cec495a39033d092b57a0a2d9c5fdb885a8a23365d2c34", + "281bcfa50c64d9e374903c65f079aadc7b52ba8cb34a46832572b54aaeb5913d", + "0142d4bc56a5d50f4c63a37e354c1331547fecbf7067e8db4d998623851d2abd", + "4fc9fe21f34f6171e7f238e74f605d170c9891fad0bcb01fdaca18d6173e3ed4", + "8893ebcd816321fe363358f8b937b287bc767da033ea4d366b6a2ff0f125dcd3", + "fa9023bb39884ce4b3adb04dac00ecee4297bb84fdc26f30d7ea7fc1f3fd2909", + "ee6647b2e72a5872e56facb47a3eb7d710a785da0b481ba298eda2a9a4646224", + "b9c1fa22d206a217ccb6cb2cc0e095ddc224f766d2a5eb1d9021b6dfb842759f", + "e1529493c7aae05aaa5024371288f6e8504ed2bbf2f0686a523c9d3a51f5211c", + "6481a19c8daf0ba42ddd4a0c1609698225a07f04b3a30bf2788aa6da99377c1d", + "8b2bb816b1fffb6e53b4d7bbb9e1d644720278361a25764838cc3cb8a30e407c", + "8f6bb682f87626a2b2980a57b6b38d5444c3dac39ced265215a860463370f0b8", + "1fe3cc54b77ada16e583ab2262e25797fc8e7bfc1189e33c79751dd2ae43ce3d", + "c91a3c056ad0c5bca21d82c4f5345c4aa54843be3b9eaf8b048bee5ba8b77968", + "e52424cae0b134907f15a62917deb9c2924e8d9443e461c2391e1f14803f65d8", + "4c8eb3bf0ceab17525413eae75d24371cf296e85bfce6065c8b3e17fc878e383", + "6767863ee9d79a453dbd69387ba80bf1ced604820fa0e45c5fb5bbc80029f5ad", + "e009ee4d859a4168b114805141c1d00810f90f8b5349e0465278f9a78385a419", + "c5a0b97cf5c47868bb24abc21616e7ae9bb0cfdb9a06a9434ee37c20fac3dbd3", + "b3b661717030a3b2f69fe3888fcf306c69ff857eb824dba40d1888095209c181", + "c515b0a1b4c88a964b0580d1159fb11d513f014d47f42a28e5bc6a490abe4b91", + "e10bcc0d96f26516feca641bd59b20e7f59d84a5c9277a4c7930118c13187ca7", + "571bbd4125601a1a76637eb11381b523048fd71e511816369e00e2c463a19735", + "bedfd1264e1fa7172d94a3427fafee189874b66f920e20f01baa19fb901bbe4a", + "5ea39e5ca1250321bf340bb183c55e033de92314a3e33f462bcef50c0c03cdd5", + "4e1bfe073a8907440c16e52e0713473a020657bc0527148684eab2646e0d23e1", + "54f0c3e2cd2d7232c2ac509fae77cbef88c4424aa8b0f263a8479d3ef5df76ff", + "b44594650f3329aa0296b4494858342e343e719abbadec961d566e2fc22a5ba1", + "301fe29d7f2268f73e836ef653560fe920f82f48f165fa4e0e49c0099d8c6424", + "dd3be8bc3f21e56e2aecf920560bc862c485ef0657b71a07a9c4c8474a599f79", + "8747aa68492c70a9c54c13d880af581d6bf814157be8270c081b1c8f5219e621", + "ba1fc6a2b4ed15c1e7bfea20abc3f8a7d14829fe3836bf58ca5ba0af336a6a78", + "7305a8bbb49f3f5e238d379c3d552f9e81a4aaa2df71ef858a30b73f310f8dee", + "b894c96f34d98994c681e8303194f058ae753062f1009972c45cf9c591f118f2", + "9420c88a8ac86c38f9cf243fc7d41e15d7c7ebb795f385e071e7016dc0920fd3", + "8cb72c35bde6a569b61cc3479fcb31348a4ced1c0faaadde12319b5caec9f1b3", + "8e714ee16be0535f520be4e213b1cf72c3ca7b7c0eff01e593fe8406097e12b8", + "db4827616b87440f34a4424ddbaa3ed81d4dc08dbec269dd4dad9c1dba3d358c", + "12152fc9dae2482ea113302dda50dcdb2544c4334038e31b068625881ce531c8", + "3b28cba2e14147570800673aad96051ab1e387bddc8009970fc8c80410943bd7", + "840fdb9809ab7ef287b989f3eb45c4fcf04df1db12dd744010cce8bd39ccce3b", + "3799730f6df0c71750b4f343ca633156982a520aad6b2eeb24a3dbe81418e5a6", + "fc952f09ca6768eccda34fc8ba356e49aae1d9cef84460327d7a2944c01037ca", + "4438235b35a3b73cad06636b5fa5a5a1d6c2d6110a4188e8f216f29c64635c48", + "3b74b91867483e99d12eb33f3ca8a9dc72af1bda83ed1c87eb03f0e8c5f3f0c4", + "79d8f05059e5b45b46b78ceb147f7e27083ae649717ca25bf2d9692aff045514", + "2164645e7fca323e7186ccc8055e5bdfc680ed2f4452779610adc747deeef547", + "2a9448f558f65a6edc3dc29bbd74f947bd9b04d0d71ff35898cf7d284b65d1a6", + "24216657b752ff786c9ca9f758d7240beff00bc0486b87663ac891dae73fce79", + "87e62fb739ae9727c22799a6b4968bb43b487e6788195242cfe2a31124151f05", + "5242e4c4142f0f68553e5e6bb16c5105d7a5af2a66a8599f254919cf81b3903b", + "8ddb9bc755710ff40b894b271d3aba117788c0aba5142ef321f87af19968917a", + "f79f9b846f0df1e524a45e902bb978817912a8d8a9dbec0374039ae094f261d8", + "0a3b961042c3d6d65cc355f4ca0039878b86a33a80663071f33d82553e0bb5aa", + "277797e27ab27e77a74d630c9bf013a263ee540c8231768859ed759bc0fae2d5", + "2b63ccac0b8f3a39e8075a294f3767cc47eeefe5dfb9d30c98ee08bdba629548", + "1ac09740be8aff3791f55bd5280d3e5ae622c50c91dd9bf5dc0a6229c10f8f4b", + "4eef78956931ab7046b15d98c91c1d68063da8e59e5a47635e86e4759439e496", + "76d336ad83bcc8fc83cf8cde81db8bacc7af89730627e381af21a00f96255a48", + "a53fc5ccc235e5f17794ad31df7195e32d390b722a82311efc949a17b90c4d90", + "b2e8f1b053e551fe644c0fdd21fb14b33b4efb586b5d04d8d35cda5fa9547ed0", + "a3d28f716c315be671ab5fa3a6da7ba42d297cc05099e6013a4f33923ea2cbdb", + "281412ae303d553ebbed4278df9d18194b04f44c86f81823685df07a69c9f48a", + "7e98e58c15d2f8daf90120c5c0d766e966d03a0f880d2ea63ea4840557932d35", + "801e93457c54a063460d59216583b3b09e7f4f87615c2caadc76c994bb229e1a", + "6a0083d372a7c9e4e7dac4f44c869d84e1348417e6247e3e2f922f6a06b8d031", + "68bf83e5729143ff6e788de75005ffeb146b19c422bf32e9efd14624a5d326cf", + "3153788ac1a79a0a6ed911c444e3e8384f84008d6cc6564ab2c5439b73a82098", + "81723def946dcf8a5cf9d89b0c772c7c281de165f012ad60d6354d4a7297211c", + "f1fc181bc74f03119af192755f8591912d16152c2e305a5adc8b7e3af429b6ae", + "c2751311feb3bba7f930420a02cdf299a5414f7d5f7a9a9356eca8e3de298db1", + "4f8c2359bdbea588b52d0e0d54d48174265653ac0aeb992bb5074d7cf2563536", + "850a58aaa2361cc78272239c8afcf657fc58134a402cbd5af4164fefb0f57597", + "e854cc9633bc04c8ee7ff16ae36e1edebfd3e7fe728e50cb47bb68e12f1b75b7", + "77d37a5d5b829456bedd8ce21a6bbbf96728e50a95d8f8e47254da52a5f2f1da", + "05365036e0173eb1995dee1cbafd6454a4c1e5402812463ef96da9c9a545f0fd", + "b67f073d74986805fa0ec49d41848233858e9015b592cc4cff97a726995cbe40", + "7343d08c73c7e83c59aa37e63394631e8b94f60cc67a9a0b55e7b778cf1052a5", + "141953ec0b29c3677d4a4fdef2514333ce5fa6616c641285062f6d42f822283b", + "0c5bf5d56473895497790f6a23f2ce4199b5e7141418177459cb3b776a5245eb", + "804281d013f228f3394420d0eb9ec1aafb868d8758bf633cf5c3deb5d71082dd", + "37440f26d7a98facb9b97a2a269df7553288325a982cf02895a4a887c0a7a3a6", + "dee049ab171627a4fee702031c492832830c1b43626fb02169bef20280d5d602", + "70148bb844e1d4a37b6048aa1c320d65428b0f714dc1c492f96c3579cec7c548", + "3dba0ed644dfb0108e085abc59f80ab86cdc63cf8592b19de659d5dc6249e9b6", + "a33756c06cc27aa7db02d86c35415f13b256810fddf47442d764ead92c0f31ac", + "bf835733d9ae570bdf094a0a59e9c82b493e46c9f37c7b0db9229cb0cabb1891", + "582bc0f9a5f5a7f169ce648030d94c5075a19298fb6e597ce36561b0aa5be84b", + "f0f118e27eb10eb4a73463f90b2dc9e6ae186f29ce4085ade323fb5def776297", + "69210731d64117ea26ab45bcdafdcec2fd618a7548b118a96470af4ed6d5bfa9", + "a7ed373215e65d448b55c5177a84c87cf55eeba2f2f2ea5e7066e5ba93fe4236", + "17a423b70708a7013aedb6869ade95bb31b14e038d04e24b91bfb017174cc975", + "a3879032a395a5834f09212f86626b6b4538038cb9e8ceaf205d94d8ff5236ad", + "988f4a26d242beac74d2d374029ad0c0a47844291b210a9dbf2289fd3b17a455", + "28e93f6fdaf7c6a9751ce8b793fe28174ecd11b1e54b2950f6e8ee82b9056a95", + "46662c8599d1f41f18a9bf0acc329837d033da58a22376dfda704cf9d1b64eb1", + "0249e556c28d845afc985d1c75b2c5334ddec2b3d05d3d85aac7852c99199f5a", + "a9293db8c76908c7657412093e2df4eed27f087c99edfd11b0a95490b90d5c35", + "5eb980915621030947b536ee0639c42f37246819924ce283b699b786070de83c", + "160a89a60148fcfb016f194f73a8da07c213af9cadf34bd433ca085fc383af79", + "26bd1806cfed2ab5bb321dc340a1c9eeb6996c7319defeeb10b7d990916cc309", + "46974d1679bafe11b1b56a00479dc8b73ac91f0b96842826060b3c626c860fb0", + "f5e2e60a0d5f597e98e0486695ac8f4ab193706eee9956056d9e35616380b277", + "84901f73f93adb668b0590bb156e84c0d0fe4a23d8e0bf95b43f559e689a0c72", + "42d3863cf24d6582273f59211f4dee051cc3f9eaf5108ab1dcadc99b57a5299b", + "a608c000d3d5472087466094eb9b88ccf7a50eb8ab374dd94239b9ebff6621b0", + "8768b713236960377246fc4de5ff6e098b4d6cc001bf974914c9a3978bf68a55", + "d5c5c7adb52cee91babb13068d49848e8b0b91d966dd0f8a75cfc6fbdad4eb93", + "bfeb2f43317621dc899108154281bcb2ee5e0e4b37b35e0aa9ef534f65c75b09", + "b501d0cb97ffe6d28a0615e7d5b5f9cae8d30bb65112d18e504f5d39aed20a9a", + "9e23da1601fd793cb5d2f5cb787483ea057f7807a702a2e618797625a46f5361", + "83478d079ab0aacf6ca72c87b42bb4443b58d0ddf86f5df89d33bbe70ad84687", + "1a0e57516390a6c8081291db2acee17004ce5ba0bfc67354c3a947ffb4dbf271", + "c813068d29420043de12d7dba7cd0ebc59d0027745122429abf245083ef78b40", + "44603d1fb78298901d44fbad85df8ab33415990911db2081a1749247324248f5", + "b93a70eea4c60795a33cc1a78555e164b47c3814d7d4e506331c5f71b35b2274", + "940ad91741bdbfced93116063df13df0eba9758385d60d8c9b62cf257dec174b", + "57e6690fbe46911d1133c3483a7bbb1013427e064a81f78b3edbc436988c16be", + "749f3d806d48a86103c34cdfab09f9b254814c967392d27c6a40f620b85180f4", + "539f243b98251959ad72265da4f6b4b9fc96a570f01dc8be5c5fbe71c9c9483f", + "4af29728ae78d7ad3fa3150aaa40915f83a33aabf79bdf7e045293361fc8242d", + "8cff761dc5645e069706bc019c96a52a193cbc7e6b6982da71f45ac089b1c572", + "ac833107eada1c17e12de963715e5ba1c04699e9fab992f7ef42235c1a851aa5", + "27d0c5713359ae3565cbb30a9d09736f6b72ac1a415816468150987f6b2bd087", + "f623a3204b28e53ffa04bf09a8c6826fd40cf02e14e3a1f5ce6316f80b468918", + "54f81a4418105e32426ec0ba68a83f6105d76b28a57a973d6bfdcbdbaed270fa", + "8ff85a7e370d6edf402317b9db9e9f1cff7558c8e0f647c0d2a057187181503d", + "a6fba631b6934f0d6be6ae516d07d259853234019a7dec3813bee53246e9cd44", + "7bc6e8bd0ffa55f2281c1116e25af42aa4d894d2d92806f619a4c8f4453d2f16", + "9b6f3ac939936c4ea4f02deae4a91c63c511739ae5417f85221355fd1f93d858", + "4449d07bebbb9331e945ddd1f2f46c4a578c674f7cc64577fa73f456d7bf021f", + "940d212c92a9d2abd1765497c51c0c535209b53968d1fbefbdd014a5f24930b9", + "236c31d57e6b5f39b47b396bde1e4e466beb34ab2f3973b4f5c51edd2bec753b", + "95fbfa2edac4b3da3a25c241a44a06704954d5c7a256f64c7e74419d1495ad28", + "599438e5f051fb8cd359b30c37eb2560edd9d92e6343ec0837e68fa29c362a2a", + "43e2982a4e23e5550593d6c8175d460b6de4282b79fb0c1ac6127811184c1383", + "ca9e410ae709f287d22f2bf7c30ebbd1f7731d123d1dc7eb71f550910b2187d1", + "a4797bf76f77bd519b22f6fbc7426561f6a1e80bb1367c406757fb6a4ff63b60", + "acdbf54c25a5e8e7e53a593146fac0e2632d09a9dd1128184b30da48fed044c7", + "856c761e492033f3de970707e080d3366f93990e5b5aa92781f19d17b7d36102", + "ef29d22f2a769a1c18f8fd1ff9e8eca08635c3a58d0ce2ebae849dc359984e6c", + "1aa0664cc35a41f625b50a3764b67a0242524d1bbac43d80692b81823530d100", + "dc176ebae09d5437cf460e1380d60165e312c77b3c980f12755ed586f8c713fc", + "d37503130294be2ecfe4568a82978b761b1f670961c51af10c2e748d1750bf87", + "eede6831a7581f78541c68065f562eabf72453b17dc1e9b9b1c3cd88340e7cd4", + "4033734d838c88ef029418d3b2418f84eea276fcab8e1cb2d7918a6fa1476731", + "e0c52ce197efa7fe8297ce8eed751b1f49fdb245699ac616842a4f06fe8f5f63", + "4b496310de81e5651382b4bb5e8dc86faac7139cd8f499e3fce61acea323d42e", + "9d5acb5059539e8e4a20fc68a53d97eccf61971f48a2e4a7ca70364325ae9cf3", + "41991be1351b3b3b896c0ecf7d2deb377dd10239b08ed855759f6808b8f5d4a1", + "3d17bb31fb4a8e9f6bb45c56ea2678110bcc5b9c3b198d4e1a1a8023255da890", + "9a957143b50ebb49b40ce07a541061ac45e3dce72506fda3db724d5ecd4346c9", + "0d30f3ed0ebedb7a870b79fcb7c052932bfd38d046b3ccd6842d157bb005aa4c", + "229a6dbaae7928c5736e7963c23f4ead4d275224a644d55efd3aafd54683fdca", + "54ae8c611b5734640326f3ecdd1f51f1685fb5af505d05c6b6bbe7ec6cbe7b62", + "443218ac58075d3a95d0003e86a055fb3a57f8af7f1ba3c4335c4428b6146e9b", + "de819576e984c45c5e7df2c15e6e66ce07bddfd7f4d45ec4a2e837bdfad78c1d", + "8107bba339b29bd33809d99542471d8d35a96c99dabaadcd9ffdc8fe942620ae", + "8fac2f0b2682e62cbf8ba6261d3b91d056f688aca8d66a2d746d8cfb2c97acb2", + "38b44a55ab4285a53c779c18cc953cd3048daba4498741868f8fdac63eb5da1f", + "ee2732ebdc019e3f566f9471530cd0c4b40065a417a1fd9194dd3f8721291d26", + "4c0b02339b7dbdb7940058bc8b0578d3e74fd245496cc2d7c57742b7d8672333", + "c302cb63acdc47dc3d58e156d4f5f5eca89779a622ef2925b3fc0d986f6e2e0e", + "21e7bddfab2a6c122d1118d2ee5e5542b30db3c769fe03ec4484b283d19f2372", + "16f3ffdfbc8e16ba93d0d4ffd35825571e25f36341667b45ba3610c7bc69b91c", + "a5214d2f94673dbaf9125548bde56ab81a3387504fbed3d96c94fffe94aa9b40", + "d7149bca7951e6be4b4a3a494bbbb31d40f81ec99c352ed60e0513d904fc2943", + "a1fde8854f1fc13309b5963589d839e93fd0ca57b283a47487df0c335c6b00c5", + "e220fb41b699868808a77274063259d890285119a22dc2ec6da2e044bb138b28", + "2679647d0cdd3b0ebd0fe0af3f8258eab4e0ddc83d0d6dfa65183dff19ca1530", + "b0c2279248548a71e75fa9c01ef0907f6d24fb958e0e1665aac99f7697da7007", + "ae2291b3fd12b91de6a19155e3135cccd77d1d3b15699e9e0201a291679e77c4", + "f8fb64a29e36865ae501475225877d0f729b1b50e2b7498987fe01c7a3fe23f9", + "6b65c15233c4950fb04eac8e47e3a5a5ec9a46c432d4de36fd86cb761eef324d", + "3f39a13f0ce2a7521da8ec86cb91307f12ac36d1de64b32b412d3ba42b295009", + "f4227e18aea389aaedb21e364311dea1e82a5c1470000d4b3fb254bcd3adb89d", + "03c6ed8fb6206d3c2da7d9fd178a5ccd0867bd81954363b19ad88ead0e89e679", + "07ebf2fcaf146924f04e4e8aa80e9d1f9a6ab1a9d886da9dd5312f10aa25f4e9", + "4a2a6366fa0ac9e75ac34b032087e31e51793ce18d3914ac097dc8a64f14fe80", + "011ae0639f183ad9f8224df1373bb5a4e571bc471988debd5d180a53647c125c", + "fd293dd95a623eea415b81ee0604a40fb52cb64f263b606c09939816f2072eba", + "25ec6fa5b06368c179cda7528673fcb89e90a7ab6d99a4383df746bd4d1de62a", + "8cc00999c0eeb5bc5071832903265ba60ceebb082c3b01099b762e3f1de06494", + "2fcd833de076e858aa6403b549b67a7bcc6140f130a908281e52c46a8cfeb75b", + "94ff8298c294766992b85d8e86ee0d917c76f4437b3bf4436d765469df354989", + "7435e27f261004b17a165256dc5d72edca26eef4cbab0e568cee4807c9eb80c4", + "2d117b4beb388a336c3702492f8a7efc204f1ec5b481ae9c01dc26b69d23b055", + "636e0c930314579281241ffbb23ee1c829dc350bfb8572ce9d74216a1313d947", + "a6fc63fc5f22312e219dfe8c94ac0111cb34155122a6c41abbe0265b55c1a647", + "ef8620745a81eae2f6e517c3980a8338422c9dbe6c19fb4012121a317741ab6d", + "d86c89ec6bff0ae04ed7b8d52cc375494b9ac133e0c8936986298cad88af5c9e", + "62a15f6777137480f831d9f0423bb3890c98f3a7858f9a380d393d06b685dce4", + "3ed670635716b06d92cfb53765333654108e5aec0752979cfa107372ec765ac6", + "333c47a4bf0afdff53da27030d74eef4a8ecb1cf51a6cd128acd136acadcf67e", + "180967adcc52d0d784604df238a2c367c46c2c2ff85f63dbe749f25179af75ad", + "8122864480f7097cefddf75354eefdddfcdecb2a48baec1a3ee56b7ef789d4ff", + "3d8a01d6048d7c90e4159d20c5d95290bd905ed1a77147458d0d1ff189715e82", + "4e4410851fbcfc3aef8f387717dc80d1e532849b169efc618095a7ce3112f9bb", + "12e5ee420eae7a63f9df25612c3120c6d598892fe4956b9cd6dd575e322085e7", + "252392b9f178aa08fbf4e8116a96cb50b4e309b2ace4ecbc8bf276746c52fd08", + "2511a8a08b1a520e1b82b6e4b899ab6aff09e967ba0e789d5393753e36577b80", + "bfe1c40f3b16084951dc19d9e27c42f811832a7789b802c085fdf606d608ab91", + "4b088dfbbb39c9762e74684d7777eb0cf4f0f7ce9ce8ac81869543d1a46d500e", + "65c89111b41ddf854a9b1f720df5dd6de6cd170c36ea20269f4ddc70d7109ba0", + "390a573a9ea6ee6a8967d0a71b7e20a160bcb343b77cdb1403ab0b3e428aa6d8", + "284837a848bd1a498ab4e2c7c4100386d6107eed3824fb57491eaface80c338b", + "002d7874e4bfbe1f2c3d6f4568d32f5611650b10fa2d582a9d7ae42e5a80300a", + "01d9a59ba9f63a570666caa166eef2d536ca024217d3dc826a348716a53339b6", + "1d4be2aa6a8b8f99dfbd688c80b2850e7abff1e33baf8a4abe4703d3f38bb1cd", + "5fdf7708466148322fc3d4c2789411e6083a989f398e621d350081eccb751434", + "c348c591fd1a363eca6359923c1048ef2c503b59d5bf05774a59928644c9794f", + "e929d07a74467992fb629360096da2394ac6b05d285e87692da9e355c9ab41b5", + "2b5d3129b846a158d37fd61be1864c5c2dd1695c3416774bf1e49ea299b88cd4", + "dab15443b7c1e9050eb867215b7c91a3322627dd4ea44dc31cd59c1921ff4eba", + "85a626083d30ccf09a2603e6620cc1e5f97491219a3f8615403194555294a2d6", + "9d7f81b873040b47ffa2b413575afbdbe823a828f7a02c1fed0296b133b904a7", + "0fd911507f232431234147ae3bb72bdca3122f2a1a56b9941921136ecaaf03c8", + "f68b07639124b76ab20ff1dd7d02a6a1dd953ae577d03d33a9e9dc24f4a05100", + "77cd788fc461f3abfadb8456822023755b9188f802fb03a131ebf09dd176b82b", + "e0152962b98d59fb8b9def762a2ae23d1fd0f928459b8bd08421840095a3c811", + "5657367d1da2da0be077e352483716e8ee04ccfdf24067afa2cb623ede8c8d6d", + "a6706a4823792bd37426acaef44ebc02535211aa313c266977dc472489b7a0d3", + "767c2727847e9cbb51c14139fbd4375f914a4cf169a36f068f5326adf5cda381", + "bc8ceda29ab83513dc6785a8c65fe6c10049290fd8187dbb2cbd8e43c431a068", + "5ad498fec33f23fdfeadc0c4c316ffcc1547f5075eacaa20ba7f60f79ea64e5f", + "df02f104a88c195a9f61eb3e7ca35771d1917ee46d6c6bda19cf881e6f6b1a0b", + "c8dd0cb020e16b17b5966418ea8bece0f914a013412bd945a96d6222bd1a805d", + "0f607d3332137faa9bccedadeb7272d73aa8b2d45d3ce62aa052887561b0b769", + "96df75f1ac291b5b9c70b967d0828c04fed37bb0e0eed9c32c42e72d4d032218", + "29e742bee3700987e5e56b3af475ebe5e8c937d8c3fe1b04310d0c24ed0e1c8b", + "fd873c307f67838964a0de19cd67f4a9c591946841ba3aed988acd4a555484dd", + "89b2a064e23354dbb9bbf888cb2f5d421f1ee56ee6ccb5751deab13112b6029e", + "cb1dd3ec47503ffca2af3d6db50619e8fa346271763f4653fcf2c8be15689e3c", + "84ee2906f83fb43844840ba9f5c7fdbef1cad5d5b2a28cd0cde6f517bb093562", + "586fb61c79e32a31efc8b193ae62a2958e8a1cb3b3cda99309d7899c5b96079a", + "48015d467e1551febc87f44b406d41bb52cd77ad752ff285e1765f09d3c956fa", + "02ded8aef82de603081a6073318835498e87c4a9814305926ce04d747d7b2917", + "8140c20a1c2bbf0eec738334bc55beb3d76167959c608c9781fc0e40869b4474", + "122dc6ad321b6418387484ebc1985d426c2291aeb4a0a154358e431ba8099fa7", + "c46f62919b7c73f7b2f534ef676a2d5967e291bf28edac7b3318244a89aaac87", + "66b48a5bdff228d2a3c8ac5558040014630b053f643e66f71484a94819fe8467", + "409eebd983d65028e152d49a0d184aa28d9e961b2bb3b7b4ac777e2a33d493a0", + "ebb64b84f65feca3b58ad0eb2d111d5f399d31de2895e9cd0b0e54cd3f49ff32", + "36d4c17ee115583d80dca4b0a71a3b7a21eaffa19c80bc39123020fb1c5e0e9a", + "36b2a15df839a4f14630bb6d1d264f9cdd8211e31115b5274a432ed8d2e54462", + "cec59525a75bfdda14d7c7e72ec01b6fc6e13a65a966cf087bb9b5a3f84d1c18", + "c765a8017cc1e03443762b5f627e131eaf56fdc3db6162e45ac4b204eab30e4c", + "66590a83c499fb7a73b2c0f4107ecdaaac5fe1723707f5af236a56148947f9fc", + "9c8168fe207a3892bba7df0018b996bb484067da65870f195de4543c96d4ce07", + "f2f6f6e6029763e83d17c044e9ae2c0ce7a6338f06489edfa213fb6ab073a31d", + "563586344235324e7e0071661093424072a15c0edbd59589877cad34d5270d62", + "a880e7336dd340ece7e828bd31170333933c1dd2edeab29086de243104a85c05", + "58f5d23b688b7212264a731aa82d4ad52e8722e511de386d5340def253274172", + "07fea4d4857a8a6cd2ac9a9bd02a010ddd2b45f5b9b8052f86410ec9364dc307", + "4b93b9d0626e46aedd99a51d6c19975902dda813a2f0f77fbeaea5742aa29ef7", + "1a35690eb9dd416a4beca685c56adaf296132269fb27fb8f4b862c8081b0fbb4", + "d9178c3707b19aa8221a359cf92cee0e9f3adca62f49eb9e7831e6848fb96e90", + "cfa83e202162e376713f0d740ee7e7a435950ea19f97d80cd8a220c9ba95f29d", + "65b6891320fcffccb2cd4e4a406a4e7137e7b897735d58167d0f855257b8d91d", + "6fe4973a27592b8f897ec26c8d3285354635fc89f5415d21a53f5867eba15b32", + "60c6d212e850bdd8aee70afc28a4036b93ef33b035e6f4902ffdc1c2cd242205", + "f3886c9ee1b46925b08772e4f25ad20e5d7547b3ee2017a8836f29c58c3449d3", + "857253aaf527dde456458f617a9d06b9b63857f192b2e157c66aad442a1616b2", + "bf8d45415215a40855b2777b167ae3d64c53a4666fca6151c72ae0de7c09f60c", + "072c1363aeadded99fa856c0627c3e0939e3c3dd8648964f0fa95237277778cf", + "4a21a1cc425ea87bb67e8f1f962f53d74674ddd4c92096e90f7e729aa3a78555", + "6ff509134b5d61468a657e080251bc81c95ea45280316f273425892729fb813f", + "85e4f2194f788456856e3873e4a9619a85d2cfa2781b9dd3a1910b0d85df4fed", + "774246eeae3b57b59ef75f3e0ea67c2c1191e554986b1f4f82b72d30fef15c40", + "d67943d9b65ee430706711fbb9ac0b2e3be005b1f74406892e4f6e4fa4ad0bb5", + "b0db4bba6de559408d42e11f2eb9083141ef51f0b5ab29f47362d784a1a15e00", + "910d56781efa2013133fac9d05681d3c4c9628f297fc12db528357d5131cb678", + "3a8af7545e29baf65710321df93a337f32fe2d773beb9ac6f7c4e47946e2dfb3", + "9c27f755cdabfdca56c3fd09d155652eee4f31d94005f37a04ee0567bb037c62", + "789ea5ee0e648101230b5e91f7ec77ba69c6fca1afbd905eda995859ab4fde3d", + "cdf184ad2a618762d611559eaf4b2eefafe57388d693a136ad6d3efed516a8f7", + "bf44646cb6b6a021b737dee18ed58bcd385b06366a8d6e7126302c89f478471e", + "fa0383d67bb95d7c22df666abd916b62cc43055cb6a85fa8ee0986600482b5a0", + "46e81373e8e9eca584653f6fcea36c60d1770937442d09653f2c56a7b4da14cc", + "29862c8f0aa375501ff77c1df95b6499f67bf6bcbf6b37970200f4964349816e", + "21214c6655e784771a6485e4c583d3a979c98d92923f0607f55316fd36c794c7", + "02cacf64c8a2a16608717587f349d7268d731afd0c422a74d15b2d5d94d0ff0a", + "ca6ea42e841ead1ae32d1e1944cef1897d121b00c8bf9a28da49f19f62dfd83d", + "660241dd4d58cc6a7c8ed2259e9c4b1e031b751a66a9337ac450d0f477ffeb6a", + "0beaa5cb68847d9ec77d7ac0e6878fe1f3bbe4a3f2ab7a0e5b9933b17d7d1a36", + "876f384afc7b73d3bea1c444cf70dab45d3b01090d5e39755476e35b7cc235aa", + "84e9798012f4c082bc94cfde845b6ed83faad83c3921dd93cd823a8c00d14250", + "23cd8a237792712a124603912a468c6e656766053b32f1c44e92f74a46e7f76c", + "97789c9e4cd35a51e833f935b643d48c705c690e8005a7bb26718b5933fbec4a", + "68bfc26a67cdf532753175c84cacb59876045dfbb003cbac006fa20640208ac8", + "f1c357bbf06685faf8d67a1d1f6a536d1ef38d018ece17abfb45db1a46efbfe0", + "568a02719ec1ab12762496f1e5a37e249a0736643b1b9e852c411e680967b00c", + "eee7e4e5af1b8522fea7cea940c368bde65e3b5e2f0606751e70e4e49fd149af", + "a1fe9f859ad8f220d007929d7611a26db531fa333fef5e797f2a76960db7d551", + "160aa2eee66fe2e873e1d43a45a4ef132d936eb383db71b06e5aaaed9d0133ad", + "ce46e9464601629551d3a1ff99db9cd669e93bdfa3c1c24ac5e3db6859fcab7e", + "8f340e79b0cc002c4a1d341dd4073b1f79c092d1b9624177aebc0afafd2d6545", + "8c9f4a434ae70c45679ee05786878610085952d96ae0b0c1ef0e1a5bf53d274a", + "ad2d5e875207eb10d087cdc55a519ff83b0b7cc831a05a6d054cc895da0417d7", + "40635bd8960875abc314f5bd5d4420b8d16fcde8a2faa5dd5b5600163cb9f744", + "07b4a2ec28d1f3ef3c0def441498b2d445eb19bc33543f18c6626cb9c9efe11d", + "034a907d437e4bee626d75b4ed375ee6bb232e36e37f67238a65b7ec592e3a23", + "29a383399a9e27d12203782c1f16a0388f8e3ef15592be93fa7a12508cfa77ea", + "bd125ac1908abfcf2215d83aadbe1a9bfc58b721f9efefd09b73c568cf50b645", + "bd1944b57ffa5bdb0833ce05fc9b7353689d536350dd6c241c93422686f5a204", + "c6ff1e49697c0c300726616c1b9a5aa302f1ca017fbd0ecd5b0d3bf0f147cd44", + "85a45f1adc701e494d13ac4efce08ed84a3e95e4fdd7ce9d1503642a90002707", + "84db106b103dd5f2df81843de258b63b2a9962be7539c4a170057793c28e7a18", + "57f5f23e2bec7ddea761ba6af37406d0e03f8f0affaca4748b8caeed8749e3be", + "d164491a5df6feb415da1484b381e6b2521a347ff3b3b3d8c76b1161af303605", + "77a9aa79438c05ecf5b712ed7f5dd64a284fb593dbc654375c956282cf4dde42", + "688d320262643364ab394c0d3cf5c03371e59236abf23f9c32873fef4d62b921", + "70af0196c72ca3b806025aed02856ce0c08c9b3820511714163a210d4e938155", + "7117c44d9e6710b9a99adcfd005211988a2f6285f87c08dc85784cd62f6b69d3", + "a049839a9a15a47adf1fad12c8b6c2d88dc7a6c267989c8bf77c13b63f7323ee", + "7fc27356e3ef851933af7f3d5c9f64deea195c750ba1c22c866fb645edf8fa9e", + "ca776833bb50c12284793c553a484f8bb7ce927daf91f13944e5b653509cb66e", + "dbbfdaff023239a102a1680eebda49243743e92361de127684cccd7674fcf579", + "111669698c40f430c8e0c9f245fa96f915548c5712b18daf1818889ed038dcee", + "b4a82c3b0819b7fd74b9cba1ece839b52f7f71eeae68a4e1ef4a78d7ef36bdd2", + "305c2ede9d54b012a36992b1dd82112d0dfa192cd8fa1072db2da098398e380e", + "56da22488e9bd56a507e45b9ecc206c11767e14ce261860b23ef99be2441c365", + "02567d979cfa67cc0e45756ae2020405deae3b3f7b4fa0603d62a62205ce210b", + "8b0a04efb82f87165a42e8803a377cf6fd36b960096b7c9f0904a0b56f2b3d98", + "3cd06354c79a3bca139dfb798c8f6176edae474f532103f016c241bf53a1dc31", + "42bfbeac4fa8ce178bb6396722757ca64078bedfacbe19196c4d01822fbb9bde", + "a07de02c6f311efd2263a3d4811c82803188bed8862a4737bc05b7f26a16f260", + "81f0f87a6256c05451e084c3f709340810d17caaf7fb6cd36313fb1ed602f743", + "8095e1850e05fadb235d822c4080ac9fae301e6e8db97e90326507ba0c6c6f9f", + "0634bf98d252deaa131ee7257fdc617abd085f7cd07836223c3d4930eb11b234", + "d962cef652c62d103333c9a7d815650455ecc2bab1884fdf7b08b9f1c05ead19", + "f05ec64a06bb7b056f642059e1a5507fe03f7112f4522d3e4f9830c845bf2f3a", + "d9e2a7e4c1d4f7dd03ee56fd18f256563353f6869bfeaf11070b598ce781d50a", + "57da2310d3775f3acd6163081bd895e09a299fe891912b5313a31264414b55ad", + "95c04141c02984b7bc228031e068f161595f29f819088868f93c14f170a51851", + "36de47f5120d600b1b32976541d65f4db0e81b9f975e3bc42f6f422d6904bc98", + "1866813193c7be7373f83ddfcb6eba870be7554aeadb1bd0c64dea40fd2552eb", + "bfbcf17891de1df3f5fa1063c2089adb9b3ac1c562676eb9b4dfec29da3f8a72", + "5733f642fd9e44c524fa900700f88eeca13b7caa00994093e2a55b3f6c6a75f3", + "e66eff93e64420df0d07cc8e9f207289aaabaee4983cfd79899a6eb065ef43f8", + "5319c208eb233b45e5140d3e8257dee06e8b8c14157671a68e4829489b5ba4c6", + "ff0f858c144df1b4b11869c9acec603493fae1dfb56f86d12d18bcbbea3d5579", + "e47351bd50933887cb46b0127330c5c54c3acfa4295633dd2a2c1563b899f7e8", + "c2619d1a6158dd2aee39cc925d76061dec143c3e97ebfd8661b8ffae3707b65d", + "25983ade35c008c152e4548b7d9c1033de0d17f785d0965992a425a23b1b2bfd", + "d74bff083b3fb95080dc07125f16254c5908817cf6fddfa75d4ec536aceb2305", + "280513776e4c4f4f0d59a56fc3be698808fb104f31e4ef5a080b5368d95dda6f", + "e658f7ea4277deb6bc9c63676877b71da980ef2642c73da8c7ad09020ac6f744", + "5062f324942777a39448555557140af64bc9b5f7af4b085c4704950752eaa2aa", + "d5fcf711aec2a9ce3c6f5574d41720a4b4cf0a5ad3fb1333246fc95f003798d2", + "8b4f172cf8d5666b19fe1c856be233022c88915bbd1b3bf0691cadc12104ade0", + "e10a491f66083bf6c6f86a8582acf6f360b7c3c65d98cc094eecc298bed9d1d9", + "263e7834afec0470a2ec0261eab4b8ae89cef629ea819cee957efbb15f70478f", + "0a5b7e3a85a3c15913a6df8d5fc5687de1228a1592989dcc8561497133457e0e", + "571211c30a253f11f72a96b5a5dd8a3a68c6c8b4a25c22e1e2913618722acaee", + "342ef75b6921246b95543304e05525d1397807eea862be1e64bcb26d6e3eef73", + "3b6f2d71284dabefe044ba5c6f2aecaea9ecfadccc42272a87e709f82e1aa907", + "93151ffe38aca1a7fb0ec2f7c193028be6d8b9d36f82ce3c014592112da22eef", + "91865fd101bb6c6748f59d147174e88e8c8ca6658b2d2bc1781c523e8e450c53", + "64b884c05044f57dbdae0aa692abcf5952651ad5547cdcbcde00f505a2892588", + "168f288f42350c63fe9ba1d5c91d58a7b2400a20f6f2efc7b20f0adf643035bc", + "96138c4385c5013d838018a22eec7e3a17ec3ad839cb81cfb5ccfac9e5e7e3db", + "2010b3449665a66d7f171eb3d0d41626926ffbbfefae7f9f1f0653d9270ad343", + "cb4b7ea83ac5b343cf963ab06db0ec37503c1322e89dbed48276c0ab905d5b71", + "27f613bddfd8d8d515233dea7824317962acfa9be51a3adfd8e32f3168d8575c", + "118699de932eb88cf717ff90a676c05fbf18fac0cf4bd23a2d8e9d246b2bd7d5", + "777ba4f7a9d3e27a22bffd414a79093b9312f018f987a72dde30757e8eedee9f", + "d95d09bbc359cf61c8525144c6d13ff698adefc1969c5c5b52773a1986b787f7", + "3988b12eb72dbaa615f69c32d1597001348dcc79d2ec41db761f071bb0552fb9", + "c66535864c5570d7da2c9079d2e51c9eda4aaae43a01068c2823737e650bb666", + "9a16b79beabdfc1a7906d7473eae113b16c9835be9bf86c50c5b26ad20b30dec", + "ed76da345e5a032b928f7a16b91d7380e2315f64f6db1e46d7601f5158cc3e0d", + "e7f954e327425bd61a840eaa28d583ea180185a3da4a63ec59ae3afe08c11a1b", + "2fa621832477722aa44d26ead75f918d1780886a10dc86027c6d1cc0fdaba7a8", + "790f099b7ff9d8b6d4838a4493f54721f4864e1fe3e348aa1738a6e20f69c55a", + "b560a84edfd39aab60f3ab7f27f88e327e930f345bae9604d4e4f9aa80a8908d", + "63f0c4ed35c69eb5df1471ed0411ee23d9aba94bfbb0b95c55996b908fd89dd3", + "47d27172e1f24118feda08f2c7e9a03660036672de46bc530c28afb94ab32d31", + "7aab9e4a21feb110526423d64285ad8001643949f444caa61800e19ebda60e34", + "daa0d0288ff6326884056fcfb236eab32757eadeb046bdc7249cda5080a1a260", + "5d8f13bf91ef242417ef58ba7a1706537e4d365e209b7e33f8e0444f01f5e974", + "f1a95330d4d4cc4611c0b022c58870c99dab007950f1c57ded207990cf15f65f", + "011aa8737de808f5bac84210e2399ff0e514809b05892b6aaa1f42f44f65bd6f", + "297605eabdf1fd9e7765f6f6fcd17adfe01741cf2eefa43e561fc5f2d3885692", + "3790ee028475cf56e171b8f44bcafaa45aeebf57e97a6a96ca054a36d3ae589d", + "1eac9daf10171d4b3888c62fd24fc019f5b25330d2e6b712bf53ac86724b2f91", + "34e31a672ecf1a72b6022cc0cfbf381fb424654be9381db647a1da6a68eade9a", + "a23afad315292527eaa64530b1b8157d54fa2f262f94ee12b6c00ba06d9f5a2a", + "4d887e1d189104e4c9e3cf9c0d3927e3fb10845cf76061666eb67f308606e843", + "b4eadeb20015add0d3aebc827e1dc23e0ec33a2619ca0cba9244713e575eecf2", + "60f8afebcdf206d944385067351ef06d6e15cf41779f5f0227435dbae747204d", + "0ca7a0f561efd54c8c795b3e37c3dafec5406145ebfb12bebee81a4cafe9d86e", + "12868c14551b4715eab774b115e74e31d80d0f530e5133efc5f01af8878a0513", + "6f67cd92f71fd830e3c8e491d2eb676faaaab464825f730da8a357d2bd8cb12b", + "b36e0facdace7c06183001879e96288073c9db8357bc983591610365f116d0b2", + "8df71693d5bfa9834d8530f11249a50ed3fcfb5b3d8797c51609e6b58f19c80d", + "293ff029c7e90d751f4b9be7b7cb689d345286b7aff253952971d70dd4b32d4c", + "b084171a098a7c2382bb14845a7f94ceeacfd680bde8a352d3926004f226f0a6", + "6bbf21e4f0e2c681313705b1668b8a381dcc5b5f7933a9840e80a01a3da534d2", + "aca55dc3063ae77a6ba2a2dec664557178b189fff6d96c502b91541280c908d7", + "97513ea699704f42e5ad856e541171e64ec4c26315d149202c4bae75957b6d8c", + "a5f21c50bc8a5a5e7fbed9bec7609b4ea221e3c18a9beb83b70d47fdf32c2411", + "478312f8b1d7018e5bd68cf01165349357c4664f6fe94e76ed5c7e0111bd1696", + "f6bd8dcac9d1048a9e9b03efa52056ab88712fda6baf14237b24e49ad33d7605", + "31d5ebff0bd1438a6afe86b08b3122e3a6cfbae703c4acc6a29554f9cd3150ed", + "b933acb4297e84dcd54c05dbde673db06e4882ad721c001c2d07a4e2cd37b035", + "0208a9b562edd52bd944a6a9b025364ccf1b41796cf05c34e0d975f460925cbd", + "e47f70dab31bb7422a89afd4fa2d13681d9cfcfb84cc8aab9ae5e3ca9a7f1276", + "98b4b805aaa139c3431946fb537753e863de771b54bbf767a3702249d0bf5897", + "e0575a2b8d5204ff3747e0de246f6aa9a004e078c1f6af07f80a0c6aaf517908", + "3e07a21c21bef027bbab4c076716293f87df01f2d2a747eec40b35207c866460", + "5a95b7e977f91c485ee51461a48c185e7b76e0d0df0d25910eb662d3e9489d62", + "24595b086ed0f45c06d8f55622c50b6f0933b831634118193d5db1e12bf970b4", + "4f4538b08d7cff2998d0686a32a560c2f3c11a3be0dec4473b72263e2891381f", + "f55bde7302beab980691a38cf3a9b638525ddc7ea812eb02f794c5e564dada61", + "29e364257b782e9773b548377466294c927cc17a91797d445fa5066eff308886", + "1cca1ece44316661c04fea5289674318b57d808c2fe25f23a3818a4186ece2b3", + "bd186a4ea44074a1d305b496e748ad7810a0c2baa296a073906eaf3cbc8364e4", + "b34e9674934379e1d0cf25141a9c1090eee1b0ca513fd377a4513990b8fcf2e4", + "9212baa96ecc66d190d64199e726a05398dea1595f682db3519602f175139ffc", + "aecb07c858c5caa26c38b2da57ae100ba08fa1657e467463e8514de8f022aec3", + "1728eb38aa83f46e9a6c3b2e619309211b8cfc2488af2c1ed737471f186718fd", + "cb83295f83d10bfb32de97d87fbbb53b765fc73ef8b3a8f5ae038821157f00ec", + "5706f9cd9ae05eef5b7595fb2a4cdbb344b4ef81c446f60b19a009d15cf2f253", + "be532b387354a9987648191e47ceb05c94fa917d0440339487492555b6144fd8", + "71aac3d66dcb54d0bd9c82215ccc112e2f1ef6fec07ec7c8245ad3f5bb158b12", + "f5560c2c0331c53319bac9e46c14ac5edd521a5b9961d0e7d16fb9250a8430b9", + "ecaa3dfc4c7224b387db7f9f9ad7e3037afee9ac6e4f39283ef43ad8c65cc767", + "6aae729e507afad23830e39d8d1f1f2be3da90314e421ac3dd23df4a42c0b664", + "09c04e66f4a456d7317940be5730f85ea26c05584f23b6506867d7007d4ccf6f", + "6b06f65416e7775f5cf8406820d73b519b18192b298220c3d147ae3959518e96", + "316a66ba576d6a8e2e17b4f9682c5d5ec801abdebb5e148a5e775e8cb3df9ff6", + "55b0a2c2ee8fc7edd6704c987eb6d057735f6efdce9a3d787687b411a759a674", + "d6f559597cbb4f3bc5ea3a2a27b3d954e1109b9fc62bce27410021a4345bea0a", + "78750dc3ec1f878b97a9ae6888c457fe98ad2a82c200975f71c3924ab4b654e3", + "39040ca8d3cee9d67605ae9e39dfd0423f3faae229071158f8ee3af064517ccd", + "c8c32191233b5453ab906450ca565345380a60753d7abbddd49e506b82593d4e", + "060ae662625a7a4e02d83aa78dc6086a7b5577356e47ea7fbb9bf36d8d761619", + "7a9c6b6e07a8b0bb5293fc622b4facc2bcbe8665c1cda6845740377f9b440ed6", + "260e6d9a6e7d3dd1cc48a54e50f6f1dcab91761c0b0b41eab781135d6f484f81", + "b20bd44c78944814ba32ebe1adab5610fd319816cc1fbb86f23982b10b8af45a", + "d99303da4a5064aae6ffabcc8f0513515879c7b4680b2df3862249966bf26f2c", + "ce71facbc3c8325aa86b0ab6aaef2117facaa9a3e67fefaa081b4a74b5b227eb", + "e6a17f1488000fcb262e1e7def76e93e8d303d2af1097904c5a32e37d7d9b7af", + "67b5a3fac82ca750e6cbd5faae1da5b86e243a8768163b20ff3d8daddce089ec", + "234712b4c9490125d83e14bf1deee10183fd227818bd4cccb44baed6ace16e7b", + "3387bffb6434585345dee9729a79682f6073f993f5ddefdf742310b207d1076f", + "56c8f56718049aab3868a8157c2164d140dd46e1fe61bce13a8af83b3a60c966", + "2868767a532c213335603219dcd15f8694b8606c121c56e60b3e582ea53ef542", + "ea56edfaa2622239915e7ccf3a0070843ca94a9d2fcd2fc539e383b03835a5c2", + "5c316bfbe1c2b569ff37cb76a6d00c585b013451f46fb81593dfd644b50a9fd1", + "b0c17ca904dc8cf7876630c8f84f0e6b5999058b0a679a5ee9dcc4c25e6b94f3", + "c049557faf6d56fc9187c04676003ac1a66fc0e304c096f4ea203d3388463977", + "8cbb2ea37095872d65ea7c91c45710f5fba532797b1547ed5d9ec4793c55b5e8", + "5102cb40f9374444aa34703704ba84a700142c24ddc97eb01ecb7a85e2ab380b", + "3bb05a4ab93e3f122784a8e41b8d1eb8dfcd69f05f65ec9a0493cf4cd99be620", + "94181f69ff4f52329a9bf61a41faf2a16a844ea3465dd54f2510127ce9ca4778", + "e75bb32b461e12c8b3cf4d5c4414f5d6cabdc3fad9dfdaee87dd653b66a8b75f", + "08f5182dca39b4c671ce7f185d7483d9574ff01108b81efcbf4421908758973a", + "1f73a20254759d8b39141dc7bff3b96ee338281412b330ee0f579683ca0bfe6a", + "c38eaf467f3c954dd13140718ccfb1075a477a49500ff7bb141f1fd4f2b3870a", + "5ccda4ce8e40642ca7ff80fc014f18bb092b3890fe35a6722dc33c7b3a213951", + "4ba13937b9bd1cb19dd698e5e3832e4a0084681a816268e5d730fc22656d0233", + "13e95db4cdafb30237f056e4b9de4ab97ceb3da5a574370cd5144f008ee96d81", + "11742ad1fed81f1d1c900e7ccd805858019a85d95e2ced393699c178046e1156", + "f7979ecae51fc39fc18e623ef3a23df7a95829c835c1f260878e2b5947001efc", + "b25fa675cfc7081217e0177c33db339aa06a03b8239cee55ca2e5e477920d3dc", + "2b7a0da43d5e3f12129d4ea6df3e9d0a825bef41958159ec0180d51110198f49", + "ceb6122abd1bf7539280772e4b005a82cb7e4ffdf26e57f868bfce5b93a1d2e1", + "b6ab0925d422d5c90d690364e88346f08dbfbb251b0dd5f0ddb5565f822ca901", + "a7c317cbdc90785094ad41096ad6fe740e88d53c100ed42478d34d995924fe36", + "9bb44d58dce490a3e694f8f34a423068b3806a3ce1acbb4c835e3b8c2750c0c1", + "bf96579fcdd22c366ce377bff7d2a668834ff686b32c1ced4d6fa01cb0f70baf", + "281ab45739944651c3b828c6731384b907917f40e46e73e70935e449ee0cda11", + "adfd5d1c1ec5f8e94f982f73d2671c57bc75a62236f50be4e5176dd3ab488cb5", + "cad5c72e6ff149c6a8a57477c0e96d85eb761488bbc82d64bb12224e4af00a08", + "1abab09f6c76b5e63725463bc1ee86cffa070e12d7f654f4a764e134c236deda", + "b0e119789ab6c3d7c85bcc3fa9e78dc5d92cf8c4c84662c373d6db3e966c84c8", + "d3bde45cbedaaf35748160fb4ca91a80f2bf9601ecc35f4e2830a90e0bea15ec", + "74dc67b7999c3795bd5abcf463fb0c3e630a3fae3f27eab8b1473da6c2a46423", + "b0056edb24f48a1b58f93fe04536ca8f6674d249bdfafc57f55df70fc9c08962", + "2778f5f2ec6bf2c9f2b346842d9eadfca9d41d93353017eb66b1b2aeb5ea7a91", + "7061c16e14534d874a2eb1ff019a07db9f66eea82fa436b7beb93436fee1ebf1", + "28c6efa09a5a52a0a279c374c4e563d1976b03685c672685d914d15d72721662", + "bedacdca3a597fb6b9be70ff3835d4f7965d7bae2c71eff3516952562fbc28ed", + "6297d9a5d6ca25b653b97c9d4fba56b454c52e42c221e668ee65be5ca3b2117d", + "03b25cfea78dc4b15c7449ce2450b70da4fefe1f0658ad31074aab2eb537d34b", + "8dba58f88e07a6ad60c56e7fd6dc5a3b5133ed19374bfec95f990b7893088bb7", + "d90a90aee45e829db884f2d80c08e0554d616eb0259a567a00bbea717c0676e2", + "d8e7de5a7f62c73eabaf6d2efa92d74867b21d277055708262be8d48ac5b3f7c", + "7c8808793e75f830b846be6f7883f8130023848faa3f49aa5cbdb429cc5b206b", + "3af9fedd03a7116f06cc73f4f8f1eff69f77494e9f61459cf011a3ecb9f2659e", + "05771b2b077d877833ed5f1c71c209e96bcb413cfbb4f79908a4768e787f074a", + "8742814461f8b193fe2c7211f866e16ab824b808eda1b4e51d04cf9beb23dd91", + "1347feaaeb576c580c402e61b71e71c047217b5de143a8f63cf049a31a253b9e", + "bf6885b66eddafec93f1f3e201cc457ce51ff32710fcd573d4c28db117f38008", + "fac460a8e51a6ff7d7303b291d9c6a1a09feee43d7c28629807bc210202e2a0f", + "8a8463a5eb6440f1305aa7a98dcd87242c0d6c9d92b3dba815a6c2105ae94b4f", + "fbe6adbb981cce94ba858eda47af6f329082ef6add007c6ba04881c3f546ec76", + "373f8163668237a8717dff9367d152884bfc33e7b96db471c0c3bf370dab21c7", + "3a0d18ea5d580baa74a70446f87253f983dd95ac3a77dd61113a3206214cce2e", + "f291af29d92189e130d7151f4f05952df40e17ef29e2dfbf29d491d03e259116", + "d41abbf119271d2fc834119d2e2e5cb2fc596eb2eb3f128fc14918b9aca99d37", + "0cbb887fd49d226b0635a20525d18bdeff7c92e497c6d3c8ad83d988c7f7bf7f", + "3b1eb972059ca6ed73374f59542ff973d61d945a41f2cee1f5c67fd885241403", + "b5b38be9fd172d7995e986a7392b80847249bbc8c72ebb407cbe330dcc02a45b", + "badf5a1699ab37df0638b9fb0eaebdea965e4801027c6c4dcf9c53bd70b9293c", + "9d8227d645cb715e30201815c9c1363d0aba2229648f921621b4117964aab1dc", + "3426f186fbf45a82cf3f11de75ccf7fdb7c67bd992670c120041e0e502de573e", + "d2cb3a225d233c980c6d0d9a7bfac58b2d4cea3180405b5d0d9bbeb71eb8faed", + "5432f79575fa0e3efa0e97b54253ad8be29835564731da84b22afcc16b2582be", + "a36abe0f7c41064fa4600e29156a72f5c8f2c7a6b4e254df4361d52b8cbca949", + "058083773dbb0449d254d614e11c7aebcfd83bd22806d8f169da3e61cb9475ed", + "357ffd0cbb2880b88d0d55f9e15e8ba8a3dc5b1b10cc7bbd5e2c2ec7166665da", + "a308303fbda6f8b4edddc07c687e83b426ce0e6a5a477a3563bc3f8b5ffbfc03", + "b529ffd26abee3037e117121c04f4167f6bb00de259c2cdaeff279a74715599e", + "ef264c4f48ce8c5f470d68624758ba456ac3ccd335f97ab8dde399375987fbd9", + "66c86b11eb03f7209f9ace371210ce6244e9e1343a529e114470114584465907", + "1d593eb86915acc71784a82ed639ab37e96d6c589c7419677369559fc75d116b", + "6c9427eb5cda9951ad207711b9704ab899f56d8067c10eed0b5bca9fb04cd201", + "df384a0b0837a0e122b804d9b77e0180ff0bb48ca2314a33e8b09970b1d0f9c4", + "470dc62696126e8d66794395d97a28503bb15c12a4daa5cf10ceb87bc7490175", + "0e95ececfee017c6960dc606e91be1b5a3b7da99c6b80bedc5224cd26b7ffcec", + "0002d4001194800888eb184fdc500b994e37ff01e7893f2cec985d915e69f4da", + "31b2c6ed2cf437a8a8725940b3d5eee321f466fe169c837f446ffd2c4bfd7acc", + "d4d475d390e9cf2781fc406d8764092b37228d3f84ffe925dc6836b34849ce0c", + "459e515d59722bb95b82fa1bc2d859deef4d53545597dcf5f22f59810d5f073c", + "6138c6cdfde116c962df4aecd0629cc795f0f5898f740e272ed01777a4d9d35e", + "8cf8cb4676c0ba53b5ef99fce9a157016a8889b9ffd29cfa45a849a4a04c680a", + "98850f2c66d80144448a01d9194075ede7745adbe0048b9b00703c7bfa32a447", + "da868468d0c57e50fd9374428cd012a92f3f1146dc01a220e43ae3725c3eca6a", + "deb3e31cfc8f0b2e5ca93abd131a6e4a40c45ee9525b4c9c77cc92160598329d", + "e6a61c20fda8a0f1a4eb096034aed5057d2ab5e0e96ae9880335bc97550e919c", + "f611f93c718d272cd378072a6f024dfae00553d74bf76bfbb4c75eb0305c7315", + "469934e53684de5f7331eab064bb981ef63f31a83c1c71b5fdf12edb7c75b509", + "0753480b1d429307b5f34ffb8f5820d1c985fb9e59ff46c582978d9f0816230f", + "136f87eb5785550ae86cd350224db409e974e70d2d4165e5266838258bed70ee", + "4426bb8235f4648b5b6a47a87dc0e45800391fad581c3f351c4f101333c69f58", + "0485b080bc2fbe59011e814fa26af2edc0650791471541edae22cc76a2d4a7f2", + "cd9e89931dfd410ffd11dfa84e6dc9b49bfb2f3c79f71f39baed7449a18e36ff", + "45ac2dc8fdfaded14123cca97c260dd7e8f2300ef7cde017bf41f0960b8ef44a", + "5081948138d02afb27a76b1d632ea80acae9b4b4b484ae39f508e138546f8d31", + "0d26a22bebba6d9944bdccb8872b9656f180f11b7c581cd48dda998b417cdef8", + "5084e640ba745c7a92fd2099477a7fdac5fee1dcbd6f2ccc4f37fde576447c65", + "8d85217884967ab550aee0cb8ecd60da69f6683c230bc6236b2a5c5a535c7b80", + "1f0ec3442265acc3ec6729c0479089930f9650580cc7ac7f5bbf19ea202c427d", + "17546367742e9a3197b04bacc995d327f91c759078ff5ec5c67027fc24e7242f", + "d3bbd33dcf31fe7988533fff39b8e4e5ee4891202e75f0d3d84450c1a0a762e9", + "adfe9ba9b10ca2316ae77542ddb8cc47c1273c53bed7ea06c72421dfa0c42845", + "b28f4526431d061091033a86c29a0714b33532ea6a9179d208e47aa41c5f2336", + "b5f8f44247f567b0fd4d6fed845b25516eb0bccdfde1936c6f610ebbbc151527", + "f5c2a2263ae2d1ae6b538aaca1f709e398872df4ddf32bfbe803dbb1325d2f26", + "c977eadb684550abfd013b22e14df90a6ff746b84f9e88f6324a3899d5f47926", + "978f1a493dd975343aefb6234291b9811a8fb45c5e4754fc11ddf1815f82681e", + "46cdc796574dc8cd59ddde6808e08a44f559fffa2d9ba917335dfe594a1718c1", + "9a4275929cd8db7dac055a7afd08fe46725a12ff11c3be1e8279b76efd2e987e", + "89bc193c2ac61d1c980e68038ed1f355f8a60a9baad145901a2f3c0436db19e9", + "f5ccb8ad581a0aab43d092f4b3909fc641486a2c3d0af7141f57eed2cea54179", + "ebd811cae9e2269c9ea337c80a300c9923906486c31b2505016dfa77dc2fe91e", + "76b334370abbb47ab92990704c28a9add8881f9b9284b78ca459b7f2b3773e5b", + "1742426ba2cd5edd1643ceb164fd808dd7e0b66296b7609b158c9662e1a28f0e", + "4fde356e78564580af248a8a9943938e96f7c6730c26169b14c6a3720aef417f", + "99678a8ca156fd84093c900d1671cdf7706313ee86c7f8a4e85c61fe45f2cfd2", + "a4ab9d4088d81c1e5b23e47aa71f7d4d3fd495a10c148de3c0c3c09e92133050", + "11ad87238467344f2fc876fc038f712f65553ce7cbf773d64612f9eda4c8dc4f", + "b25565dd1fc1202c40fca4a76bbb3ea41dc97375d3816eaa13a44922c9df0cc9", + "b3b5fb20a5872c06fa163b3c1f3ae1624d57d58b83824f4b9660c44fe7d61b5a", + "7d7bf936b7e2d595285dbca4789359bb5d7e5ca59d139c9942428fe0cf5d2563", + "fabf4b34dbfb1128d5264b918df220d9f888cddfdb2d2c1347c921dc549f0d25", + "965cf0c2509de710183dc6e794c3e741b19cc2b1657dcbe3a4e3137101189e00", + "116bbc8102e1b767bbadb104e64d8bcbd51a2b22238b4f81e69ccc9208371dd4", + "ce954f994201303570385f473f0e240e795da04e8fbfbe1ea3e231b06568fd20", + "b32350e014a72aeb38cab5fb2e649809449b58eb9bc3f5503af22a1af6c6e5d9", + "0cd43bbbe76a4ad3947ae10e24b2ac391e55cda8443353a3319bc0cd4a6d70ae", + "57db68a4933fd0838d358eca34b7677583340cb99d2c684893ea98d37a256381", + "f8b600679410237825b73462997896bb134f72a0bd2649ee3f61f34248c175b4", + "3c1b5d39f9d23669744155753b7213d6d24d191c68600daf2bc1e50c0d623092", + "33be59a820da4802b506b893a966339d9ffbca5ef842c6b4fb0e9891aadd02cb", + "1ad22ee8f9b416951f0b8feab32c0719d5432023f615c9156aeb006dcb7276ac", + "9fe8c31d237b968e788d3fe9b60224c7dc015adbb48f5cfafdcc4c2d06440a25", + "e68eb08c50b903118f8d4d2dbef29845ff3ad9eaf5d1a1f5c1b04b28df8cee8f", + "390a2cf3ea098d2851aeb9742d2b270c613b8743034f9d5fb58a424b5bf46138", + "e4c616127dcb78ebc6e7b84fb9d8e8493f6bc199df957c8d3a81cc47c04ba2e2", + "e0fb3cde11cf12d5eca02cfb5b2422292fb5df30831f332fc06160717184bff7", + "499fa5e1b69a54c3a307bf080bf0d757b8b3762fe00b69084b67fbe5f755bebf", + "2de2841df5d490ef76908f9e2dd9f122db3df1e75282b2fc96171388469db73f", + "cb23c39d5ac681d239d4a6e97a31b479b9dac2af40cfe3a2874d3d42bca94477", + "48d93143f1da4f69b5066827f35f924c10de9784877c183e0e2fd9069f7d5edb", + "91e56d1706df065b777b6f8210f5e995cd5c0a913a94142bb80ece1e157497cb", + "6ec1b4f0ae89f3af94732175207775963a6400c138b423474273124bd6df62a2", + "6d9deecc92b34c1dc995eafecfc82408d9e321cd88525b0555aeb0590da9c957", + "394ece05b2c113295177d14dff85a805fc94e272ebbd166eb1cc1ba658a4dd21", + "1e3f8d372a179ddceeda09165d917bb0093ff707a937ebb23c24b0e712bd06aa", + "4cc054a27074e5810f31a96f20b2427e39c7eeaee82043258ceeff967d35d620", + "9d48a79edc7749d6afaeafdd86c87642628b663dae740dfa15ad7f8e3813f179", + "b03c9eaea719e03dc0d800089cbbb1b56f3891e03404a937988dee22949cea19", + "eb2a0daa8adcc27d223764295490a824095f19ee3683c413638f45321d561b99", + "1cdc44f83ac1b589a17e745ac1de372aeb0a73784efc9b7a4f13bbd0fff13053", + "203f4d9756ea48322f59dd6bd5d273712240265967d72b5d4b2b58ddf18aab3e", + "9db89903650b66c9fe226ec9481dd0817b7437d8bdff4168cbb6b539ea1056fc", + "f20f1f1eef369b10be29ee22a5fb8ec3b05158070c6cc6d7f90e33332f10384d", + "ff78df562cc48964a52f6c055f8e7fdc82eb8f610d18c9d2980787f93cb19225", + "df4477d7fd01687d3a094f441e6a2f42d71fc32b2c6303c7a54254e5e4711fe9", + "34a0d35f0fd69bf26f273b92ef6593a8352760564f517329271fd70611cbdf8f", + "6ffba2191c7cdbf91c88a634a320246ee4f9fe22c6b1a8fa33e44e4029201a40", + "a0ce46f14db8e92763023e7d0a345a88aceccecd8f0f209d6347c70664d2e026", + "ce2218aa795aabead71c4274127953f050eab14237d22ef6c0a2f55695490967", + "668cbeaa83ac432afce23d8e772496533ef46b774916c05b5247a9c08fbee53a", + "2480fedff03a0d0ee3e4e0161853d93454704a817496c68f3b709a8b199f446f", + "51250e36434d84569a5cf66bd361a2cbf7badcd3b4d0157d8210fc8b7d745f55", + "d1833b8620fa47b36a48fbf081e83c614dc6b7c096aa05ba99f95cfc591c6b9e", + "a302d5369e711f3d01f8dcf9579e4d61322bc91c8068e070816cd71fdb22dd66", + "a1fcd0f021761a3671ff0b8f9dc8d2f80c978665477f5e5fa3f0ef908e5e37e8", + "f5fa8390888b32e1d24f03e3dc7f8f8603585562f48584f29dd26a8f1f3bdef7", + "1acf7d9a17b795e6b7a5f8f5650fab9e10a561b4fc15de738cdf4707742ffdfc", + "bc1af418b0569d4b7aba109fe7a44dcadc969c2516d48500e0d3575b85275aa2", + "6baf693288973f5e331df00ee426ad85b6e8b89f23794d367974e673130264b4", + "93c2c3bb8f3aedbd8f240150d7524ac96fd69aa52ba0d88ab5e1b4cb23efc542", + "e35286d32805beb0935408e1afcc42a3ad3096148767e649e28073319c07d949", + "a4d70a8a3bc7a6cb0de6a91bfe0dce4515c83ad8c7942bc60aed00713fc97283", + "d41ad0ea2e560de3fc83163811273078558906eba7398eaa07b00bfd7369039b", + "a97e3c44931f3ba8ff14667d9a335e2edb48b292720e781a31225361d1195f26", + "3272576f410c455cda0a3832e42e06e4432e840c7900c5a3ac4ffbdb4fdbdb91", + "c22071d7c678dd65be118d959f11e4104f59d4a0b435a0eb83558522c7fdaab0", + "f9c5e093670ff47de0d0dd7fa6aabd7a151cc523969e5e31621d710eb2224ccb", + "7a8bbcece0509c71691af836db47ffe05cf2e8330a0f8be8d317c5abc2580af2", + "ed3b4f56797565b1676f8cad4813b77e4f55a7733912fdb92413c7a7dde461aa", + "ac92a234051545750e7e5af8a07e694243c4537a597eca0d86cbc1f6e618b8c4", + "767748de6ada4ba09988e748ca217560781e16d7ddf0d33e0d2cfba986de94a0", + "5805ebcce84c99a0b38f59c24e711f80104e0607bfc8fff8b46c19c5cc0506a1", + "5ecac6268f2dc0b793e559aa75c644fdf9b966360bd2d2ed86b872bc0fa1b606", + "2e80172769c7d5234056b50e5f1bd991c970a5096b1c61ee78850f321f277e6c", + "20f7750fb60d12d2cc64ea21861858abeaebf31424598e34ca2c412a7ea41fa4", + "8a13f40fced2695a442e6e957feac347a701ed443b973a7f7f8fbaf3146c9dc3", + "84ef6333b5cb9537c7a47e2fe9b16d77a9f847f67a76e01713ea91bcd8bc0c25", + "0952a994178d861e02b9db6dba7dae00c6159f681b5c48e7455b30fada4940a0", + "176c100a5dafde429a68d0ea0eb5e5d9cc044a2f56abb38921be0e0d0ac61e55", + "82cb0aad73058b7a201688f4d9860e007aa7a856e93364764abc437b46907ac6", + "53bb4045b0d23925f21291cb65144fac8e6c3f0cf64b69a84a5da98039f0a5a1", + "809d81212bca8562b19da4f8267dcaed1bfb697ed9c4231f44958f616242e859", + "52f378cd0f8785398ccd80ab42b95a549bbd94c9f1cf5ef05188fad564657895", + "a111e8df0575df0e50ba1fdf21b8c7b86e849c43c59bac963854694977c83f72", + "7ab65ddf82315d5510dcd80978f113a768ad36edd6c21892653b5f12e2865cf8", + "82a3f1de676ddbaeeb43452134061758bc1a1aebaceec41959831d3a6de32b46", + "aa8612a3cbd9dcb44eaf092a265f9e00bb95c5203bd9b19ee28f97a0473bffe1", + "7294764e301d60f70497fe67d534427c580b70b4c10d73127d5f525a6a0c69cc", + "7ad8c342c59acffed9834026c943624d26f2e40664898967b60184a8152e57a0", + "99ed0cc33d4c895f45a2c256b9419ad92073da971f7af2866e5a1ccf76c80348", + "9f0087e78a708766e464a82c5b286e697f6bedc7b01f1fe585efd1419ea8b429", + "c71b599b6e830f8f4e70428b4bf3215bd704d51f438f12ab6f70b164b16df468", + "380024224adc8067c0599c09a0d7555070874fac4c67088e84ed2eb2ee25459c", + "e8e3c23cab8770fec8e572e36d6f364e7a0147c1020738ea1087aba06f8c10de", + "f9e2881615fb9c75149bb1475e04b6f715b753157a11d80c6a73697b356d2d8a", + "7c806a50f5f9759dc43ebcd8a3cff3301b9d68e97acb90577c2cefd4c0fad5e0", + "ca5d8af518f7605b5528def6f6ad13a89d2053cf1e8c1205f439a41f8a6fcf88", + "3b020f5821b8ac5e78c0cc055d3e3e017bfa1d68a15b4f08a74efa45c7e2d689", + "13c41ff9e4f479fb7c99bc91c3d61a530d60c0ddef0fae85f36400ffc0b91b73", + "ed51b7efc0e0a9878f90c1ed98c3b217e285f7b0611b8d690b553d94d3e5ee6d", + "6363ed68145102dbec3ac3f91b8929e8dc0f2217a0879cae6b3e6ad114ebb704", + "347333225bd9ab00617423610652e91abf920f033a3d7afe96bd7c11ca317997", + "95872766b040b1b874c3132fedc15343a81c67d40dc4f4da0289dd03b8bcda74", + "870bc53254606809ba373907ea479b690e4baa40df122f141ef85831acca30cc", + "7146eb8519311c7837b5733d8d753412adaf70d27dbeb21d1436219cb74665ec", + "bab925ca1a1f92e0d086631c5360913bd423ad98379aa0355156db661a77db7c", + "ea57c1cff0563d378275f272cee6e2df9d4170c2deaaee21dd2ece02005c2e22", + "94566a0c4e89094f6b8cd8a0b953ca2d4ea0e53947ba14b5a0fd954870ed92c6", + "b3551d214f6a1f6a3f2f2d8ce2616714147a8f32e6ceb5203ceae708bd64aa3e", + "588ac434758b863ea0168e22d9819de51eadeea66a18179910072457da215ae9", + "819e79374bb0da200a8ebc5b9190fde1384f8c33f8068b3c6510f7176d351899", + "78ce017741e6c106f52dd313193c1d2dac87358559bd716e7fee38c9bd8803a0", + "2e16bb1a9bf214b63372a1ba6fa5a502686a323a531fbd0d600d2a00a23d8ad3", + "44555683533e004a23364520d8ee6eabc15567ff18b5de8954a7f99a09c1b7ae", + "5dbfebb1f90a65e340cc7da485ec1f21f2bf478e1540e5328a3f6b9bf1c142ae", + "a324a79d58e406f477bfd4e8e7ec821644f21a01229ce1f9778aea19754d53ca", + "e766567f90d86822995c707c627594941462e2389338ec523ec913ff250d7206", + "f8655f40d4c147413b8f06e36b7c30651ed4c2e5a5307131e0f27155f5aeb256", + "44adde170c21fbf008a0c4c9ba491cad8431655f8d2f5087b76eb712a9b0eeec", + "113bba45f875ae2e47887ab561f548b676e989762ad8996d0b57d9a56427a79e", + "0be96f076786a1fa800fd7e29bc10abcedce57aa4e6ee0ab4aec89748c24a34e", + "2036e8c7b646aed16edc083be321a9146e94d82153c6023fa60d6ecf122e1405", + "c5577997249c406ea166b696657fa35e3abc4d566db69b187ca40f874602ea3c", + "d67352dbeeb847b6ef13e116dac0ef405b9bde53ee77171387a568ec0a9e4f4f", + "a017b033ad50d74e752e34a240dddaacbfb7cc5149477899af7470a1c00b3d05", + "bafe1029fe4e8dbcf70d2032c8b11ac2603c3648467dce4d92a34810d5b60beb", + "255db407d926ec049ce2a29cc34626438bb9c804fa4615a26474f0369771c2ce", + "100ebcd7563c54a810431535a2ea875f9688f2f28f8cd40182908490cf64b787", + "8942017884af5ec639e3fc7c53bc4564221e9c61e1c35cd79a71ec2e1f59e166", + "428f23cd8dfaccd17e40146ccc84f3aebeacca0e49064033bd868f41b02cb6e3", + "b599073ea9d6bf42e047f68c564f53b5095b4c02a20e695d6e7cfb286d576582", + "99470eaa64df50777224def633b658de6eeb72494d1898363dbdf5b16cf5a95c", + "9b597666f7e6ae3a90dfd434ea4b61247db90b6f91cd85424a083e7e357a4045", + "66a476291b8ce47b9a38558f0ef1143a4851983a752b1ee45d4e8941ad266f5c", + "5e44a712de961d5492ebac788a800858d0e0b8eea80eaeeece486292ce3ce43b", + "890964cf53eb6680e681ec3028a71be004e2d52e6fdd41b4c1900eaf9a3388f4", + "db117d1dea4d491bec0bd6c79c27b18b8db0e3bf61d69957606c3a9fe10d2409", + "1b04ce28f99a52093bdc56e0530fb523d3a04586e11c5d3555af8dc5e362a180", + "8a2056e3d55aa228306aba7f7365623b4fa9ff62133c0c57173d9c9678cb7b09", + "64fe9875ce4e1e4501f3dea3311b4eb68cbb30b8692a8452e1943a2ae73ddd78", + "17efde8d03801ef8ffadb997c5b7e671825a873fd69689d6130873888426f062", + "5de16be17149cc41bb534c67489ebd302b3df7531d52f9918d565ef80f14c852", + "5beea5c8b4439e0c6554269d527b6f2ff1ee89dfdf52d4ea99d153e78aa9f77f", + "d377a3ed06aa3dae9057a489aea63be5bdd380786881e4a0c1d7665c8eb57bf1", + "07a6b3b3727d5096b48094c1dbaa53e42fb50e85203eff475c4f4cfac8846959", + "5920b4f90c09718d7c9239430991cbdda4513fe52cdbe7ec620d13a8dc05b1ae", + "7f2a9703584311e039ed62900572060f8a2b2ad1936404db7caf3119146fb09b", + "8221c6eeff9d7fc412d25018e0fcd9be5d0859ef70dd391cd80afb582635c41b", + "a6aba9db96b1bb0ef9eaba122dc6822a693eeaa7b27441c9c722c7eefaa1a875", + "4cc845901b861886c204684d73700bd9bb7e1b0c96e93894ee9ad81bf0761cd2", + "820f0e7ca5f903c2a7cc4bbffcd83eac881fe61a5d9bb06c1bd354e97367c355", + "a7ac6342e919ca06e0dde8a0f43f8caf1893f24f356c8a97db7f866b6060ace6", + "81062f429065c752dfc1bca1009675b4c1858e18dc58296f2ba8b6b94ce1e53d", + "72a55d0ae222a67cfc65ff618adb4f69c81cdecf94938c3fa58fbde262b0b02f", + "b4b39a2eea4f48958c9e44a78e483633d8474367ca4a731cc05925e6ae25292d", + "98ed7e7cbe43eaf462b37274c8fe56f9d4c596965f704d23aca452ffa4a80945", + "a7a8a504b49737bde60de58e51f73a73fab33ee184ef8c138c3e5a560b707f21", + "3d34c5948da9c60065fb84ce84e307a64a869fec89bef0cf01ca8b0a58ebbd44", + "9c7a1b81162528c638e2d4e80edd314e70e369ff6a2dc73b75e8825bcd488678", + "49d1681c068d14eeb2f2bd562082447072c1e00fc63f2c9c9f0fbc4ab6cbe99e", + "1f13dc3456906390293ad719be3f5663831a315c3d3c12812f09b0c9d7084ecd", + "f94c1c99629223f72e46e154bb6a8dca579c285c583c67def9dbcccbbcf09c48", + "f2d100a36d8cb2a1f10b8b88ba9e392b3b6723910b7dba4311b08678eafbe3e1", + "631833c37fb6d08ba7104603b2ebad86b57966c3b460cdea11b2d1ed9f7da8a0", + "9c5c7f7987a680bac4cc22bfac3d4697f2e17fe5c36fb72bf7a4b642c06a5da3", + "dd410a14ac26b3266d153ee48cfc5a7950f22fed43db254fd0cca3f4f77e12c8", + "62ceb0c65fc10a74867d6cc7d3f36b2dd0812afd44dcba3d5c27703789310fc2", + "e855a5d43b5cd8413c2e1f939dd51d98e1d5037c0cdc47112a677a31c6474816", + "29f2cfce22c7a1507c96f79326e7da3aa6966b7b46139142e457381fb3ea56a9", + "86c72b790006f8d426c98d9120842b8fb53175ece170548246a278919342dd12", + "e7edc7b3f841fc11041748b5d2d32c8a5f39c0ba3386c3ab19d945e501a10491", + "c648b7607fca92c6197e1287c72829eba8942e490594dfcece8a8af96350e0ca", + "a4a89a2b3e1adb86868bff3c54f54907492a183576d3723f235f751d27c59dfd", + "c8e6a9a8deb4d34098f0193e779a441ec2a017fa8c4983aae8172512cb909017", + "e7ca2c7153a10847e81c0a6691a7760a45b77c5249743a6c6e959606110dc0ee", + "c7ef8f48a27eba687e9b5f525c2cc2149905bbc54b969bb8c9279da1ee03f086", + "0e963c818a936a330de46fa56284930a35a0519c6a564774ec0bc9e7964e8a1f", + "eb8f6b9eade33dd8eb4a6aa215371f1dd7891e95df94b974c697580aaac30eb6", + "2f8f8e64e4051a816728222f8b06c7540dda241ece8352fc7753d81e66bf0a6d", + "9e5fe172f3f6c99ff0fbb8c0b041a5f017daed461f71a43efee509098f7fc7c9", + "fda2ea0be01c8888e95174471efdde0c710fe1d24220450073c69173217f8dcd", + "17972ca1c9fab7af548921f7c36f3e19fb208ce26dde6697ec2db657b1f89aed", + "a4bcb1bdffde3680d58222b6ec03e08f5603dc80f3a67c324ea31a6b10a3b291", + "a83479180ee209cf58819b6d0a770c1944b5f4841490b609f6145e1ef366cb43", + "44efffb121df5ca74ce4782c984585f74699f1cb50f13ddece101482fa7800d2", + "ce49b3e65c0c59cd50331db28960a67a1eab218e4e218a02ef29a89141a19549", + "57d6f77adda021443b8254b4a1fc8a7539337ea526677367243abd1fa02d94e5", + "aa53f4b2ecb9bde8b990f6d7aea8066f14e351045899166d2e8fba3ecdb3e1cb", + "d8d65d511e4e34f193742e9fe0b148307dbd53dd069a684e7676fd3ecd6b436e", + "302cffdda582b90fd952edb762cf01197c31bc1f65767b0d0efb6f31b71eb779", + "4cbb861f52e287a71564d54e8adcd5ab138e37e88068ae6300299704957879ab", + "947c54661cd93bd50cce1ca04467027a6bac1a21793fbf31d1012e7338f1499f", + "fdaf112471555279c522c3a47df137812ef92dff74d82bbac596f8fd7fd6fd4f", + "01fad30060de492388e28ddc48cd71e485f7344118232f1d87b063ad96c35887", + "398b0cacc01367c7f614971ddd6cb463380f867eb98b7d6793e9b9b14e1d4f04", + "06b80277198bed1451b86016ec6e1519f5760a2184dcf63977af88c805ace80e", + "4e3b8c6d7fb3c93845762777260a03ab15f217a8cf24053865bafa1a6b7650a4", + "baa58ad4a496eb68c48dedae8785ea727923c61d3e3a593e816d26ff987f160d", + "79eba6996909b33c77f048ae21cbec92173c3be39f0084cef6e6f1d76815ca47", + "31ad147fba7762ad9758d0997d53e9d1d11c8539b88dcedb12940f6aa683b57b", + "20196a89198f98d877d2713da22f87191f432a2fb9cb90261d3a722e25e5f6e8", + "b374edabb54680272e0c878de9aaf1b3959431e8efa871c984c8c7648185d99d", + "30b39eb853e8cc1f9b5f7c2f1f51a0b215f775cbf27389504e5dd1b838ed51f2", + "d6b88d7fe596b679507a11f9e544b6a9cfbaf1f5b60184ffaa3e8a66f3b5791b", + "8381f04609fb3e80111e82b14f8477fc96b87d8b6bcc2013e50a7feb502e0aa4", + "157df9eaf17fbf22359c8283c336be0bed7acc98a776a4c48f639f135b98bf8a", + "a8d163444bedbb92c8a6373b7558bc6122cec699fa69deba12ae053e4ea91e6d", + "752104ec4870c52c1351be9506579481eb8f64b6c7d977a56e9bd0f394c141fb", + "d0a4e8c579b0e07ed73018b92f9f6686614b3ea100857a8598d19bfb1bd0948e", + "0b696e982b4bf41cdaddc5a6b79cc2a09efe927d9a2c27a20505d71709382f22", + "e048038413a0aae39a6ca1019acd72aee81f84d89d1dde4797c8416487597c8d", + "220d28fb0242dfa1af79be134537605cd89a921c880b6550c6623b0ccb37fc67", + "bfa5b660d66e66414c2bff8b37f7cd3a79bd2a798a0b7335b573c13267495dfd", + "a91c439b2460c3c4ae11405558d079ac507f41ce6f3aa2a09200ff7c8cefeef4", + "d5398986015d891027bd88db2840eac8c85c57420a0ce68c832039795140b0ea", + "534859fb7743de6d9d56ccf43d9f70cbf0cbf444b5b826d58f87323fc667fd40", + "189f8866dfe687e1ee84ca169e64e9ae49655aa6f00450517813c553a9c1afdf", + "b487c632124b65c8c5943627fbd9bc2f9b4aef95f1716248203e3f79fa42402b", + "3ed57a44073dc76f7b09d3453ae0e337f32d8f95f5903855a02458c72907a62f", + "14431ebf7d168f66371fdef198bf760a0461393fa7a93f3b3b892797cb3c21c5", + "8d955701688686de47e2f93adb346ac06e9b1d528af6dba983fcdb48e77309d9", + "a0c626be854e1979b3a8390dadabd2defff6ebe854b26978eecfcc15cb4d8176", + "cb65b5e21d52a4444717c6747dcc42eeebbd51efb4d83ceb5ce6439d0125b50e", + "960529edd9eae42e8fcb53fdfe056099e058ddd2abd5a4e5003c36df8fb68235", + "fbd8e9efd2cf1473bdd40c81581fbc49bae62adb99ea2e40f9dbc4fc43a096ef", + "3ea88151b5c0f3453324c4f2b065b80cf37ab25b3631d7f2e7e941d1531ffc07", + "f1a8420850684edaa3ae6bd0f6c898f005ab4a0920233ddebf15c90110be8ea6", + "38877125189dd5876761a2359444bffbc035fb680a4113db90e37a1b28313eb9", + "b1a134400ca28d0e00e65b5a31312f4a0c337a74000a52f26d5cb231e32e88d8", + "4278158fbd27819bcb52071c2a1579eb0bbc295019c8c3239c8e6ce9efd94b22", + "982206f8f59eefe774c6fb67fb63cb663f6b3b6481c208b71eae6f508fa6aec3", + "0b3c8a0b86c64aa02a817b403d9f4b93f57a408df1cc593775823e4fbc93328a", + "c2b02d30c3ea352fab3371fd4bf6b8e63b76a42fcd1b61270e3e195a3b068e29", + "07bd1ec4fd159b326a221337dcb5ba7d7bf9e3b24ed6f540d25b79d30335826b", + "231008d2b0ee2447f6e49802dfac20694b5e1508677968a325953cee977c75c6", + "3037c02fa7504fec92e42fc5cb9885913ac331f345a56e030d81f0add7f714a0", + "0377ab255464691c2a230ae238fac48450460c27ac4ef8499107184324bc8eed", + "7c32e51761f4cb5eed9820886575b848c52b692fcc2e257e9fe8b06ab1edff3f", + "be8504c84c65baf8a3c6c52165de33a7ed41a718552da7cf5cbf83854225d5a5", + "951c1723da906359d237787f993a6b66f2cbf88bc14e052bc264d90751860c23", + "6ccc0bf109a7cc599659ab1196fae2c93569e63241b6a163058690f03ba92f21", + "bedd5372a48f2012d377c91c068d95f73168d0d2f2e11696bfea19016c50aad8", + "cb94b2deaf3cfa01bc33c76da5e3f69ef67d84da0d200ff49215c8d4cc7ac3f0", + "485c4e86e1880ef61ec159ed510c8a2b8b11cd7574ceb8797cf88cbaef28450a", + "08758ca6be22d708f7e8488c296bc9b1a1b1cdc1f956c925a94a526add0b82ac", + "1734da6c4ebfc3682eb19db3e25ce3322286baef9f3872b802f85dbb62001c7a", + "81392bf9d4a52f7a2e413104a0a9ccfba33e01251919aac356f50e39e8d16e9f", + "4b722b081bd2e5cd9086679b8f22c911c3c0e5ab8714af38384db3e34f3fb257", + "7a812b9ff54155d2a2228d69a41b34a36257b9e9bc9834d6cc62f8eac6d2c4f0", + "5b4b07ab882e99f5a6fb76aa6ca50cf7e4306564a0bfe800bd310a31f88c9554", + "6c5b6ec11708b30265fb802761ab5cfe3cf187089244545f66216505f7a8c97b", + "9e1f8a31b8d9abe0e2b972d0f76ecc7412514f2ea0f3109f171876777dcb4a6c", + "c6abd0f745821d0bd8bf312440fa6513ee3be84754f87c33c4b97b8c9e8f01a9", + "0245897e7b72797e498056e2f7c26038c5dd74277bde466f7d2aee590ae4471d", + "c5aa88e9db60a02e9779166d3e0d2c7fde31aeac900f471f337b8682888e3d5e", + "d0146ad09a76b89e7d59740db0edd3dfffda7939525feef097768fefc9673d8f", + "413cab19ed3ef0b0fece7601b496d725f6bc14994b3b1556249bfc666b5dbcef", + "aac3cdd1249d81411b5f36a6a332083cd2827453acc79730c1701772ffb22b84", + "7522dbc732f6f90e5ec391bea8a818a5b93992eec0c048378b436e121f6b56d9", + "f20597e88e594480b373938f83c68370f06c103e1d88f55dc9d00d4a70ac2041", + "53fac15d083d1e2c13267bc68446bd1bdf2da0d90d24f381402a7be089ff13fa", + "8739baded7903cbe29b65396acffa76710d0df47b43aaff949d81c9c2234c070", + "95e20eff3534fb1c36b3bff327a01d15cfb17b62c90b7b8352a541d782e5d70f", + "974da4bc7c3078e01298a1f4ab9861422d7641c6460339e34d3729bb0b71e6d3", + "14f245724eff343c1fc359cd4faeec476a9c5b6c753ea7862e2d831e4095696c", + "fd70d4c895524011e8b04926686156b96153368dc95b8a45b5f726b9e0c6f084", + "780b921c817e940bb7d3e1ebc29a111ee31d88d2ad1399a7a759c94075e4ea07", + "6235d51bd09dbdc45e7fa91e3b5bccf98366b6e8eeed3368f6a293485612b820", + "e1634a650f3c7a128d42538317ede5c68bd3f47b4dd5cd72f4cb44d6afdda94d", + "29fd82c98a4e459c26667f5bece7eaf1464a3d2d0e0228c85d756ea4819343be", + "64f45613565a83503ef37cd3ea7617811c2e4a1c85bf08717af09f7c451cd6ec", + "125af32104cbd615f8a211af54594a014be16d39d657613a0a33f2896210fc51", + "48d091b4b56fe5d13fd1ac168d759c20b16c6b757ff0d24061ae9a5a4a8353e2", + "a3e195c0dc1e1aa1a8763929ff394e09c63b28fa3aae6753fb4ec4a17c7e3ff8", + "f858e47a113c42523e38037f9e47a0e2ed743a8b4fcb7599f9db7484bdeba6fc", + "7cfb766b4650e07ba2bca9978e9df0ac4f179ee0b65d7ca0d4feea55a246370a", + "df7f0449755ed0c9e0bf2f56c421270c5679f6e837923174d3c7de403ae67cdf", + "8b7225b50fced39aafa03efcc1152ae180f3eeb767a74e37129c2d727b052682", + "e8dd815847fb89d582dd22810d109f52c8c32c8873f33fe96c85dc095599582a", + "d29d95e8756853df0db0268011ee733f69162dc820949848d0572dd55f471ea4", + "3538ba40ebcbb5f1395b47aca1831b59261ea58b045ab2b1f90b4d3067e26078", + "d1c80b0348c7a17016ad9c5d390422575deee560528cc66de55155ba8672186d", + "5a9fa181b80337bba28c40a330dee69f9c1f72273f4539b52b61fa11ef6ef027", + "31174b9a4da7846dbe2d14e468702d3bc7ac8142f4f8c292ee5e26265f7bd25c", + "62017ec8c5b820cee27ae98f3131ad6da355d07e2174ae37da67b9e530a7a9f0", + "c6992180dfc4d16cbbd9b80c35abcfc0557fda72235de5586197194ba2990105", + "7030e5fd844fd2c4c1a8ca84e1befe059ea31938cc4ec9e14d44356ee0a4f594", + "99874203137176b68cdb5eca28ea835c55979d9b0ae93d64908d21a9668d8bf5", + "0c05fa6b31da7a1bdeaf0e45539dd06f79b11d9afc95f5230d1347879105e42d", + "a633f2405e597a5ca5a4904f227b21af4b67b1921a0a0d8fce186081bcae9adb", + "1a51f9904992eb3194d7fae77bdec621f31ec04863ecf34cf3d7792b2c456955", + "3b6f36ae3f6c4577fdafeb433e206f4d3116cc2a07a56264aa17fb666b129b79", + "bd31e0899a662d4985c9a774a8f993f1f8ccd9c045533e5a6c2f8c04e432cb30", + "930f96c96e1c80cfbd65e12086d31bbda1f0c60c4bd5be11b527c58aac30b810", + "3341567e8b5a59c3f1c6b27af329f7f6d6892a08fb20c6dbee3422c0f418d357", + "d962d7c537ac19f1cd061aeb8b09fadb6124cf006bb9b5dad02a1ac9ef5c2801", + "b0ce80803219fd9a92ef437811ae5c62c51cc5104e70031d26e6c7eaebddac97", + "33d48ce9f63ff98637ec97bfd64ad231259c56e4d49f210b35d86483ab4ac947", + "d7f0f2fe6f3cee98489fa3e305ac7ddeeec38acd93a873e033edeb22be6cf3f0", + "54d6d543a7096b10e67e78a37bbb5fb2ddd037f585b3f7c06dd53eef968c86e7", + "aa312ddf5b0d27dccc41e94ca0694b6bcf99fe015a9398fdb361e09ec90f66c1", + "5fb7ec4349853dad87796cd2f460d22a360f340a906d645ffc9a851f43747ad2", + "f714d0b70e6a45f231c4ce43aefb1b6bac88f3e7005a5ed812d34fa086808ca1", + "57c879cde58b11002af3f0b54deb8ede20b03ef12927be693cb9bef1d0d41b50", + "068df9aa5b5532a3603028b2681771a313d4e7bdc7c81d8c66e0db640fd44ab2", + "c672bb22d1ae0c17889296bba7112f3f4668b01e49697fe48646425b06c931f8", + "81d7c2a2e998b79eba13abaf9ad1ebed74e01383b49bda804ad7e110f8bc053a", + "dd57094ad836c86104d814f01e0f3f32913d5ede1c6e3c48c7d085261147c494", + "c777186d43853aa1a7f11e807cf5d8478647ffdb0d0e7ad5253378829060cfd0", + "4170df06622dfe3fbb7782c78a928452eb4801fac70f71c732a84dd2a84d3e74", + "8a6394a1a256b58c9410fe9c1cd369f99d0139b284d1c80804d2a462a38ec8e4", + "9a087d0013cb9945adb6b5f5d646317fdf9a1aab7702f1fb4af40065c24e58fc", + "79163edeb74bf916fb7085cd048079a9922446adf0ade92b39e06b38f41ff45e", + "3b6bf994fb76ad4c80de6065a3306171903bbdd9d50c462ae557dc82db8ba61c", + "808203c39d63f5d8fa0562038d048c874ec126ce4cd0e3bd4a1282b6b84a3433", + "e9a8dba6a8641c638ec33acbae53fcbf0ff15b35c536f5d689f19b2ee3a28ca5", + "da2f7f5edeba4ec54d54de5e937a53201c0914837354cb9e8e1edaab44a419a1", + "a993353bb408cb9631fe71b40008793b79d7a431308ac4e0b55643b21819059d", + "45125fa4a0154892b2e5225839768ea89adcd72f3f06cec121ce3f24dd7a69bc", + "6c91bbc229e51f40b8e5e4185968e9456eaf936d447900d869e4245443f25a1b", + "e59a6e612af5917ccae15bf781b37217f19f3e4e931a431c41b25ecac039ba3c", + "856be45cf0a78a381e864050cb656b3aaf14671d0918445ea94331a054bf3fba", + "0a70eb533c20a1c13cf58a4f5180cdca2d7b3ef192ed2369d0953645f8b1fd8d", + "bb5b2b750dfceb5bc0e441fac6f5428c7e98c29871ef4d96e67fb2a029707ada", + "a8f0abc8b2809471a8aa37ed31995fde6f4c6195d6b0fc9bffebda3653a6a1cd", + "f79e0496fe1a847c4e33f974554aa4bfe16b3d5f240751488b30df4583f6ce30", + "37b2f2d1211e3e550dd117072cff4015c617318afe5ff0df17db7523602c586a", + "e5516bf8333e207bdf0548daddd74f6c0720f04a426e949963d903ed1d46d9d3", + "93e3b9dcfd9cc7ce08731bbadf8ade49cb20a2d9a0a7f25d91ae43d71e3c3bf4", + "ffaf6e3f11e681c57151c42df935f87cc50f1bcdfe0d2ec84b70468074cc8327", + "46d75539b6d8845f3ca8594c64ea6c09ba2ee2b31ca910fe951532ba06b1b95a", + "6eaeb1222599229434ed81b4e3a1a7d779fcca82b0cb45b844f7289e25709775", + "56a47dd4d7a374b68628f7c1a159e28f0064d292d8ada0c7aedcd00bcb9ed433", + "e69bf1cde3afcde11d53a293d5deb018f5699caf7d5c87cf1b295043c1abb481", + "f7f8b990b11b4e1db1c34a77b0e26047c11815aa3587bb7eaa77c7fead4b3211", + "29d9c9da3138fac15f95a663053ad209d6553ee1fe25c173a98f2b073e975a62", + "74a78a4c3a5c3c03e980f00326f6bebf886ab8586cea2ca6d0819d2b14eee89d", + "8772591f24586d9bc5e396161c278ceeee52733b24e310496a8fdfa04df4ee0b", + "fe87e2f00bb868996802fa10c0c36480d5b73b3055538139f44e8878bdc162e1", + "ef188735467e3906acfa614fd6da9ab49b283c8157782af332f030f4a84a9125", + "1931cf3fa0bde6f4fb59f09e37877655b36add7528b98eb3cf72360a87d86e28", + "4e70cd009582ac4e95739f39d858f578261e242eef396a97f3f81902be75b449", + "3595cf94cccf1fadba0caa0424a784de8835b8a4645452c3b9cf1eb80bd87291", + "4efa4ddc6ed684deb329763e5e61294b5b94e90a1a44d9eefcd52b87d40a0521", + "7ae2d0bbfd62b1c281b9f4a92790783710e8823103a9e16b3b05f480f1f0048b", + "6150918df7e8229ae5fe0c6da3011070201fc27a0f69f7875dd6833f762a08b1", + "58be536b403c576096033a438a19e093aafb15dbac531e2d9210bc545972c571", + "977d936d90ce7cd1e3ac25b51537f6e92636e444c0233229716b6d1774157ce2", + "7eb9f9511d536bf1f48167659769a7f32d3ccd2879c47dccec41087169ea60a8", + "970822605b7976058b93612f1d03f39cfd93be2466b132cf5d5c4da4ee5cc301", + "fd1c39b816acfb228cc01bc9add6f967443d2342126883982338166e51278dfd", + "40cd4000c376dabb6a07d96bb57af094372ca3912cc4c7b9573408613ec475cf", + "d90738afac4de6e040aa6637abae26a02ab27bd9d72257ee4635b43bf24b9516", + "87a8c4309cdbf69509bda39e7edfa3e325a114c36c1542207bc27da1de1119cc", + "dbf8361be43ee20e0d838967564f01751f3ee602ca38f35739873087f8147836", + "695fc7d2ad232cfb9152bccd2d16466ec6b04919859cbb0d93014e34fa7e6ea3", + "da0dbc3d095a15187bce2a703f2ea6b601d11838c8ecc28bb0d822320ed08881", + "8e6d7a3f4f8f85eb63a4c6c67b7ab032d67a7ff4cff1b0484a78fbd47d1e5ab3", + "61eadd04f7ef49aa374dd2066d4411aa198044fa4bb4914443f054117a598ee8", + "bd700a1e5cc2b75481b894565cd87b26677f53e65b75984efccf762c9d8dbc6e", + "286f4192b8c213026214bf43c066a0510422194716ec6e234edce992dfbd244e", + "9e591a0ba7ca649be356c450d60185c0c6ec7eefcc93756924d48cf2d23b849e", + "1f36b48f8136721bf36e122d445dc05029064224afc5c01e21d71540781657b7", + "4e8db4e71dc45f54deac2745059c4e17b150b038e07bcab59b817e009e3eecb0", + "802f03ec919cb298277d09362ad0b747ba5c4092336d4d95ebc831e81371a504", + "504ac19d9a87bf2c9a5fed0a5dc97e350337d3a36186a7f7c35704869a8305b3", + "75063489728e94cb3f64456f4cb95ac54f86808c66355275897637dc6b4460ff", + "5740809144c45c30bbbaf6fbe87c927f599eccb4fc875f5bd815ae2bdfefe479", + "1dd9641b09374a00e0f3f708ccb6bec76d296e8b52f620467666dce2a796e05f", + "10e2f8b6293d006d5a7682ac6b9bd3bdb9f1779d9b7dda8f87c754c84d6e5ca7", + "be90230d40add9e8c263c6c27e60f03ae1fefa0b904455d1192edf15cc5c5db6", + "52974c66623ce30ee1b3873e986afe2aa84ea7e78fc809493ca7f567cf98c44a", + "05ad7542c36982d450a22f40bcc419a91d960a60f28b7650ebfafb00fbf42ab7", + "6b1982f78ffbf8edfb2a0d56af89ec7d9132f973e9a991a26330a3a0624ef63f", + "2e9c3e3eb92cf760554a8364ac9c805bad125dbf8454817ea3525125890c5ce8", + "4405580f87bf7fc3095b5ed599f1a08f44a893d74a41d91a5548e1827ab34c1a", + "b6f849b345393ba015b6885ea06a5ea19dcb2c42a33c78d81bf32653a7dc1eb3", + "c8e75f7bcc340f600f11fe4abe9e5f230063372870352d169ab3ee4e6e69aab4", + "b3812aa1c78575b2fc37c7ae6c86b4f37c326e8e019accb18baae1649e5b443f", + "956378afa239fe7a660bf8ea92a0e42f28b4cd365d4242e136c5fa985dadb346", + "dfbe3af7a163f590a8fbd04e709db762eccf179f2f4fdad59edcee331f28b9e1", + "e8e16680fcc75a8d2aa4356eeb3e6dfcd4b043c29a81fc9293c2e23474675de0", + "29e3d2ca05138ed5ab32789a8fa3a5669a471fa39bf4181614ac2e547f487a1e", + "360784b9ee84c7734993b28f23a3df01ee9a7cc21b53f41189b54f7190252f89", + "b6ac57c5cbe0dd0535ec83d46248d8b0a5e78f06e7da9bcbc04e51533fc33687", + "bdffe4a6e2006085a1c01bb9448fdf80d1c8be33226ad13c74fc4dc6bbca1a81", + "2590e3eb06f67fd7dbb495e9e26533a563b6846041459a54489e6d9aec5bf056", + "1e901b50da2a93f203b129bd1d5e6f9cae7fe53b81905505cd1ddf3b294cc3e0", + "25ade6f68bc4ac973112bdcfb476a766237bb941cb61e26aef870420465a7800", + "b96c758949b5d3dce8f57a8107d3f4714e574163a80e07fac74e0c434b6995ed", + "fd9a0f467c02ebfef650bb624f9362ccec8fde0c300422811b44b30551dac9c5", + "a10cd2ecc557310c96279d8586b74d099fb6401012d1417ee8aabb77259379c7", + "94bda5829bdbe9415d2eb85f67f8836df9500dc33735da974eb089e6a46131e0", + "313b99f814d88d2bc0cdf0f4f8f3fb3d50cfaf4a25079f25e666503d61bc48a5", + "2db487df0f53353e54cdea5c8c8d80acd24e646437e40d1514b0ec79e24f3585", + "5bbc8384d0e43c9cbbc43cd33a01bb730e6e2778a612cef6cd9adf440fad9526", + "52e377ed6367059f569e1014ff4e7dee61630ea38b3a7fdc6611a55bb258c077", + "889419106263b41ab9a61e35dc1c9686e94af2b296d5453b3644fcb1ac3377ad", + "c5fbf5390652532a2922e41a5b2437797ebed14ff82337582bcb993025a83140", + "62654cc8235adc1463f40a934a1977c8fba1aee3b03f406cc75b4f8c69bd4cdc", + "c7e765523098907e549da6fe77cbac23f111e334ba58079b9d9a8ddab3d4ff90", + "4c495b573678444e1746d7892d226e0e6d7dcd9dc723eb3a7876845647d15eff", + "9e8d23d0c257e01cdd2f83ee3f694203e8f070d08b0731de5a17175daf7e7ad8", + "cd1ee48d1f9f38648bfdcea8984d388a09c7c8a0414a269cdc9a31cfdd219122", + "58cd49b56ef23df4b303cb13d29bdc40c291b44c73c4618c27aff776f5de15ef", + "ab6df1c790038a82a256a25d656330a9ee5b1d751d5a7516257c0b5a16d5aece", + "2b582caebaac5e9ecf7e570804e462cb96ac137a060e7357dae65af6b77c004c", + "f2061a6a5383d95910490d770b61d06f4b8efe9dbc8a85393f656ae8c4cec78b", + "0a4421df6a44a35b0d5a00023c4810fac2f7ac0cb186b47f9c38c813c2cc89cd", + "c316e6c77460efee288d0166fd3fd3801da22c6f8554762287895c5dfa558b0f", + "305a4bc21d174f8fb1b28d51d890c2ee882fc4d0f24d453573375eaa248c9b1c", + "40526b87f180e0984ee7dd2bb36baba2f45525840a355c7478910783b7879b97", + "a5f837c5829ab61ab30f72047ce83e9b24cfdd325d12c9669aaa49c33c3c57c2", + "d197a1eafb1073b19fccfedaeda5220109ab894dcedf41a84821362f4c139cbc", + "5504dbcd4e11d2f11a03b50836b950929713f43395488e66365bd256c3f60506", + "8fe48c1e7d04249c772ba2ec3bb9d27aea9faca2b55fc4e8dba6c4e287afad16", + "8ed138a3db5e7d6e18c240a753a1d97bbb0d72d8cc3a192dc7bcbf768058e8a0", + "5418650f96efdffc205092a4d40759b090b4865132ff257ecb46f89a9a2c4a68", + "05ce9a65f00d28b67724317ce113427e88df589729a7a1ea305d733bccc53ad7", + "d170667e08a15e92ede444fa3b139235753c5ab96513265813660f5e19773ca5", + "c54e063c5d261b610a40bd0d0a1ccaf5b79a6bad6667574c802ef71396486669", + "5831d25401d7f305ac6da1ee55d3096329811f9695026aeef3b8a8f6c92d4b8d", + "b0cf79a9e27315b11e5b3d0e03645ec782365608334d818cc0cd0ecd3222e3ad", + "c6045671c363e760e6701cb544e7e369d80049f874c1f91d253754914c2f9254", + "701c1e9131ef4d8535f28a05c93c8a3fa21e6eaab1b3b9ef9b260fe48ba4f94d", + "3ef6588adff2269e94e379c6e4703cb32085ba1963fb25812a664da4abb9f888", + "eb15d6f8b8020bf18a15eba3cee07c75568f02f8dd220b82485dd459ee6a0a45", + "331644e94ba8b33314a9e02dd74f70a2afba00d4f31d9130af6f0298b315da59", + "55b0daded87258169a2ab82a9cd5c2cfb4258bdad31ec15491a5d2587e5b65d6", + "2d76114b3b5354701f62d308599044332727485790563e8cccbb378ebee09070", + "1a5ebeca9a3b7efb1463407927fc224944f54ae80d63038c91e74a61753ab612", + "8d6d794234a13100c7ee50b326bfc903ad7e32cb223c475dde49146cc44793ba", + "de0cab5dac95dcb978464cb4ab675957d7c9fd62f3073246b360df9bbf9d3c0f", + "dc34671c5c34a71efae5cc2c91f82c536f084943d7487c46e9b4f677e442c641", + "3e4e4743289551fff82d04bf7ef38bf6c5eb02400457a6ea398f1c5d7f44a14c", + "3168443d5f7e99252debde1b659626589ce9018ce4e0b9733885af83e63fc6a0", + "e657cd77f965cb657d50259024353df89c398986b0896880867f498670657c02", + "51db63edec4e1433810a01d172a2c27437e83488e4630a4d37dfcb494ec0d788", + "379ca06ff3623ea59074ebfb6d42c1fb914182fd72cb7785e4ee813393262003", + "51d21f7ffbe308d9d24d057bc40ea5f3bac8dd130329666da9da3868b2f96d07", + "00bb28b8aca7d84a6988402abb557c4b6181c17de14b5bc42549c53c1727bea3", + "e08e347f76eabd6c83050e8a0b6c4f462344f90ded6203c553279c289894879c", + "09cd95546c0f4b3abd1754a6ea66a576a113b09f83f8a53a7da9927442513f0e", + "c7c92565648d3c3d6d6a666e69625b8adf2a3a1a110d3f9f54d9aa8c2954bd2c", + "749ce238859a6d683c1e24ee9fa825fc63f522272fdf8bfcd520b4a5f8593800", + "bf8b030d28d259a40c5a78148dfb299a1c0e75d1888a0d2996cbe23cb36e802e", + "3634c8c639144a3c1e5f2416f04f18478fe12bd64857bad2a171c113f605774d", + "a8312252b315e288a7e8d47202455b19493c44a7ef20b49a6cf6eedaad30e013", + "93ce10f66388a3c38fd15d1ed3f119bd4c05ce8d7035e5f6c038281e94121aeb", + "da11e301e67db178c5c163068a5af26dc15c96e95cab9c818ebac0a9b18b4220", + "30f9aea5523a0cf438f7dec4bcb6f107b5681447f27faca81d3aa9ab7ae1c254", + "714ea282e6512d6f40193594e4a12c3b0d00c01dc042d30d8fa7b5fc289fe095", + "84ac5a4fe65f8b5ee828b07db208db2e2a9a6eb980ecadef2f720f9c5fddfd4b", + "bd6d6535d5a90661e4516a80e13377d185793814eeaf06ae5ebe0acb32329e79", + "ccd7a4144c70dbcf894332c9f5924afb7320d0e30729b5e56490bf4999911f0c", + "479fef441479f08e47751cf9c19035260b4e7b1a6f2db15f7cc5e8c63ac2576d", + "841ebe7f97e2985f9eb9b3c0f6603104a61aabfe08c581e76c9786632692255a", + "2f98ecd24b21972bb78474065aef20474f6d1913a5ff28f7b9df2a79a8eed31f", + "acb172ad5d6dd387eb6c4b760590c96b0519eb373d83703242702fffad8da70a", + "6d70dd7116b5d8a6d484dadfb8fea2dd0af9d47d1859052628d8b38c31da2591", + "bbb9302f8ddb6d5ac4d2d27770ac55e7171221eea848cda0705e335551c2f534", + "15872c4b1fc7b1483a2fd5174b9ec279813d83a1ed0d8186547e848a8fe41836", + "3d3a79a0e7e0445071ddcd9154bc7499b36e6d204a7e4aaa3614b1ac10f4a4b9", + "86e53696669464c81f274cab1f372d9a11d22fded877251eb7e0fdc528758da4", + "7f99b21407ed5342dc5f0c8a71b977415fd8eb06625c4ec301c7629f5bd12993", + "4770d1702e21eb44975d5fe606f1e83c7a5a086bc9d6915a1e87b090491ed428", + "34f3477288b5b3d80951b44fe623a20f9be94f2033dd373bb97870c329397b30", + "cb9dd1d3229dcc2fc2325a18df22fa7f4868899ccd0f0b7221f7d8977cad457b", + "46735b84f5472cdfbfcd685c4f9fb5ff9d291afc667f31e55c594cb727fcb0e2", + "aef3791ee2e592e74a1b5af46dffcc664cc573bd4680753d4c7505155020a634", + "36d0d0f590114f15402afb532bd41382e9bef953227779e64e67bcfbff277e9a", + "536a7c4d128c445d96e3132aac86920420f15bc88ed52adc606360a3aa569072", + "095644d3a6e4fccce02c86afdfedfb00c8b0eb9d642160abc314c172adfe4cb3", + "a5342b887c1ce6f4db184cc3ae870ec8d3e97a6e8d8d76a6814b89a38103873b", + "49d0fb5cdfc6b7ef6eea152a5f7abba7f1b63d8a7738c977dbf616924134017d", + "7317b3da75bac943ee950cb64566b6e236e1c3060cefa539ffb316b75e0d6793", + "af9e0adc3ea94519bba9b5dcacc77e28962177e654114919ee2a5574ef09fa1e", + "0af08713e56ee537a2d1c58eda3dc08a2ce2c59c8ff6c09b91da6dcff1dc42b7", + "eb366a0aa6cc5e3046a4eb20c4c7d6cba212e409c4d0e3dba69656ee238189f4", + "b1d18f90f3b883ddc659403d9a3e209371fd039964dbc4433bd4f1c5aedd3023", + "0f362e915ed4ede85fd96e238da981832181a82350a58a72a10dd5cc6bc05f9f", + "88f09f73ce6cfd2ec874f3f9bc4a9a6dad5c68552c428d13f0300c7771925455", + "1f686cf5f7fad64ecf41534b5e222e7bfaea5df3ab3046749c6d1bc0518c159d", + "e5aeecea9a42e001442bd0644631c28fbcca45bce9568d2be4c64204f80bca49", + "7ec8485f88e26772eb6a11573608c5566716a953d7a238da3de9ce86a87f7be6", + "700c36744a9c3193c48257510b4eabc06792a90ecb5c3b28671f4a795ab6d586", + "de68ee9c2cd990d3377a4c37217ce3ebc595e18a14b17640740dbc7c3ff62c8b", + "5ebd68b7fcb478df0cdbf7a419b25b1553958aa136f97f23f3c3aa206e0d42af", + "72eaa3a2a92c0c1c1de6bd5aad6ba3457ace80e5375c632b1bcb201e6c630a98", + "802a7d6cd421434226b673f4f4652e81c52d35e7e78f57c9f7da98740800028c", + "a7513b253b46a90f45cf1c1a069ccce7fc0f9fe36a9346d4da884009f962ab2d", + "05f63caed9f4a8f318b65a94d151fcf9a05abc441e85994344744a671225f23a", + "643af4b80ca8d77c5f9f92b5f3fd35151032c84818c3fe61cc883ea4df5bb5a5", + "5fcf0b4096af7a3c0e8a798d0648df9d8ebb688cfe7a248facd55c9d87d3410b", + "e422ea5cb8ebb398bd374e72635c1cb2ec195237da896eada8f36c413106fa8c", + "f7e92ffd96f8cabbb7d20a1a23624ce33b01774adb66826cb88f0f899d7ae450", + "c664de9873e37d0bb35b6791871201cd27b03979b36b9d8f7ff5f940a30c2099", + "19f75be5e8456f89c6b5c7577cb8a0e52e1111798875ae73fc65569aa9dc41ee", + "b7da8a7d5ab2fb13709f3c938de555af03ae49ffb960dfbf6161b75f37e45fab", + "14a483075ccf1daca7e670bc7e2e47ad6a6c7e172e06f364b4af7dd11667615e", + "431118d5539dd27d400ac237ed4a05029c5dab9bdcf353bac3959e01886fc297", + "03a69bd294bba596ae78aaa5a62a9d4094dbe6cd357b89f259edf0b454946e60", + "572661d8d653f3e9b4188fa716f73610f0400266ea7c38717fc287ff13140120", + "233a547844fe9e2f396fd1bfbb6b8609f37c57a2458745e90bb5f747c8f1a6f5", + "f423148591327bdf816bec58378780dcc1540fc8d9103f8499587aba3543a5fa", + "f29e261f0688ee5a4661e1f21cc303384a2b73dd293865ac0e4c6d63a9ab7e63", + "9b3ec5f10a43d3e2f4d058d274dfd68ac2284996e299811fe360d62046f031c8", + "d14392b47bc7504cc2400067e26663ab76abfe20333975ce2e72953d4e9e2640", + "1ea251bc54e72f0e0766e1c690cb9537af2d5cca8895933ee762c76f9f8b42e5", + "9e63a0e676b56a11a5f20a9654b2610d52c40c2ba53b699f0746c885ce762f68", + "2857d9344c15c3948b14775327a7a310da48cd42724826154365b43760b2e63a", + "0f033e757bc667a8b648025641080f87cdfb083c1c636b9bf27aabf424d8ed40", + "1effe0353d98ef85fa4699b1c11563bcdd5dc6e1f76551ed6f84703aeb2b8164", + "55f535ca64ae88f079e3b3ed78a738848889c57a6cfb6e4677eb9cd1c4da028a", + "6e0c0f499845ccb3cd4382dc594e895845a071674ea84af71708f54a9d47ced4", + "300ace62a9c625675f48a911859ecfeac34769ee1f34051466cb6a8e40971617", + "36555003d2d2ead4b582871d0766bea1b65523c41a8a7bc699ddaf6c697d4ac3", + "9982cbf19e7d4af5bda8e452866fa1983df109bfd87013307487b2f9beab56f4", + "00f185b0e08e87eaeafc74b22050ae0532defa5f0628fef51ba87253c6c69a74", + "a9cdc9b8f70835a18d6028b26a9d8ec4969453e88b58fb3f3534d3cee3633f3a", + "3e7db9cbd41470bb5f0ab7b17004a23cb58318ec5ddd4a2e3c1b5ec2b5d4911d", + "f51158017d9011a3e2b6b7445479fa021c467730dafc2fdbcb5fda73873e1671", + "c99e103367852673259b0384fe8cc27222f2502367aa57137ae2c60dcc8d1e57", + "f42555f2308eeadbe6dba3667e14a1728e2a8490182594b667664a4c3b8854fb", + "da6f65ad00b4680394c06218942230f5af9e916f5ad4b77e794a83fc0ef241e8", + "11592c0196621d746fde4f8303d5a8a7b450ab0df72aff6688f09f7c544baedf", + "d0baa98f3b4936688a8e639b497e8172cccd662741fd9c20eaa27402d3c3387a", + "fa8c0f1fad467ddbbd19e8017025af0c7a22f6d632e7e96d0f4c4f67e9643bcb", + "7e42ba0a90bcea0c779b2286c80cf263a33426d9c1e34ea4731d7e2ccb25a417", + "7ce3b0757005659493a4f9c7a4b65879d0578b182888ea77062fa8bd03f3c3ec", + "845907046edef57bdbcda05466ab237d503efffedd224bc92d80279244992922", + "f4a5ab6c0aaf6d922e3437d46f915b822e3d1e2c61960b1ac5bdf8e484b22aa3", + "91b3536832ddca895f0c69c016a8b0809475c118d29b73d64d285068a1c424b4", + "cfb35416db5eb420332272bbb7c131c652f8b6b0f975c3d2857718b4a2527ec7", + "f54b46b74802214edb56d22f05365288b5646638fa44013fa0f80ba6fbf66217", + "4fbfb8a7e2c74ad76ec3f73485a8267cbddb4e61136d64ca20bfd636d14e6563", + "972e19f3669e0ba7db68fdbd6ab5e2be042206e0597a4733f76ba15b8e3156d4", + "a08eb45460a76ab0e495fb81ee9a9921ab63a491913c036648f5c8eff44761b7", + "b157a4dbc4843a31b34dc685bd0ff43e3676c6a8e3abc71ab24b67a23b70bd81", + "f7f295a6dc32943a57a33e238c8e76083f422d9e12936e7df08462b38a9dc8ba", + "5b00745eb7b32959ba4bdf88e1b2004189faf3f58dc3d0652a20812a77293dc5", + "66efe465e8c12ab5e46bcdfc240951a1c7006733861e77237aaa28519e16f234", + "90250e6aa77914f6c97fe38db6e5d16a892c9825740925e855f116360ed456ec", + "15d9269966a27eccdcbe249e1495438e367a0c237c23cb100e46707410de6c4f", + "4409c934d14c8566a17e5658a0daff071bd90aa54812e10b36dadfc0d958b248", + "3fef614544d595b2c9baa9f2c3de4376ffd8e1e90958f7ea848068f8debbf649", + "b7810b9cce0612e1399427904585195d1f13bacfc7556a71d4beb757f4dcf51c", + "94a3887401c4ab9748c8c277f2d0b398abc0a2c9192fb46e80c21e4311638a48", + "b379419cb95f9e2cddb3e20d8b8f1d262dfdc37173e98403f527c71da7d44680", + "2be453e450aef30d7357f941525ec9c8e2ea8e6d98b194e08a2055e4e6dd85ae", + "f58ce618a96598e1f36560a5f81493135cc0a5118b20cc3699565f9d1ce28240" + ], + "jsonl": { + "path": "ultrafeedback_train.jsonl", + "sha256": "1677ab31d7443092de3f907492d336c7f9fb420f60312928abc037ced1fa50a0" + }, + "parquet": { + "path": "ultrafeedback_train.parquet", + "sha256": "79b2bb886b56fb770f1a3c77f34e709def1e0e4b6c299dd164cd2c44367c4094" + } + }, + "eval": { + "count": 512, + "prompt_ids": [ + "f6ada56b9e9778c17f2bd423a80195b253305facadaacc3d7f962751a75aeda7", + "206b7c5d325784cfc41d7d7dbc71c9d9872a7e64e7392ebd0371c512d60e9a6e", + "022cb84461bff2df0c31a81546908a9aca406f6b7959386cc4be2fd09314bc67", + "20a795a383449fcfe0df88091e23ef49039f655fc5056f80c410201fbc6cad93", + "0a30773964f0aecba3d5781c17af5f99d34432e08a95c50f8bd28b0450f3a231", + "ef5a3d0c28ef0cce3244a4354037cec949a1a4bb227ab95bc4f9faf0444be6e4", + "cba334209e1208de90f70864c792f2364204e5dd26d5067976addec68b4066f2", + "1a410d3bc9677f67e01c6fd1e7e163b5f8526bc9ec5d9fb5bd09d78c488edea9", + "2fef26fac8ef63829981022b8a368881ad4f763b6dc2ac95f4635b014fbae12b", + "c199653a4cad2251a14ee5c0c554a15536b5086a942ba5a9666a2ed8c7b53ef3", + "7eb7819a2240d8532605da7a9a930f1c731766143d48b73194a647c0e5f124e9", + "22519a24d763ca1d60ad87b8c984c1aea3e02c8ccd488bb8a62e3043653492dc", + "eec33c11c0aaf62414ade529ece498b6ecb73d874a032f0c7858751d6981e800", + "2fd60f842597de3a26d07c0eb813d5034053c0bf91740f302d09dd5f773e2fa2", + "1a28050856d3853cea5a6c571a7672dfbb23da5d89830696badb7d37f4af63cf", + "b523dbab7cc280ef8c763f98c42d65f190cb49dbb58575f5a872c8fdd10661a4", + "8854d06d15cf0cc4829ba9dd62c402fa9f68f578da375bb6aa391ebb3ca5507e", + "cb963530ce2fdd195df491b9239fbb7bfc8c78bb25c90a6bc21ebf8d0219616d", + "318d34270e67c271aeb9ba7531e0862417596d3a6bb118b777bafc37f46022a2", + "12fe99048fb6e1a6cafea49f4d0463704d6bb1b1ce123f1414452cabb3495d39", + "c7892dba9c5d58e26aa6ca77e47c2d236b95c4ef98d2a105c07c56c373618d0b", + "02d1ca6dc70224fc4d89f4b4301ca2289c8efc5937256f060bf27391f753388a", + "452a65627abb02d5006673654abb52fb0c026451bb27d480c421f75f7bc6aee4", + "04f09626b1e4d804777fd9c2b088dabe0a297c4818d947d29c861e27d95f952f", + "ae4a3eb718e68a38c09dc5bd41ba3a8d070a20e59d78f099180e38abe2298664", + "49da456bf373a8e4d992de8ad214db7f45e3c9caba0e7cd47e41686d8f1ca2b7", + "570ab698280bef8a1ac1342b912cea04de7d7fa55076c48cba5ebfd1b3903426", + "63d797c2b6240e7629b2f88d8ec8ccfe1e320fd4034d957718471355dc0f98ce", + "5c84c60ada03497bf158cafc0c5ecf46cdeea59f2f9ad071614300bb0215ab68", + "631866fcfdfb0150bc6f8ae9afa8c0db999a6fb7d5542c1370b753ebd301d7ba", + "4d25dc88274ebe097009bac9f597047b2776f9c0b76ee3c38c4920e42d66e931", + "0224716f5a6d92cb3d2b24f3d892bf98bafaa0f4012d273b9ecd67395c386a0b", + "1d541cdf3a09d88f486a043bd789615ee08e151224a2aa18cea889f54339aa85", + "f590bdb834c265a2948838e442369c7c541cce728bab8f5af3e8e995f5d16b00", + "86ef505999c4ed8b8099e1655324b01dd553d4d4af9eaaafccdc48993eca96e6", + "1f86130766fee79a85ae22527dc3801bdc7fa44f2b5671eeb3abe471720f4966", + "a46a0583a498ccf90f554d0e260b8ad0a21490445663b1689d49ce52db625700", + "0ef15823ff914cc7926a6bb83226ae9c11dde49e68d5fa5828b30d8d30249442", + "fc3966ea37f98e1a1f6bfbd5b6775b98101afa42318df9fd3e05d0e3c15001c8", + "a795d87ccf645ecaf293831a33646cb826d425d12654fdb049afcb44656c94e6", + "605b1dc8bb9f76c3513ad2416590231d774cc5cdbf5e0e64b6f76f12cdce21e1", + "e19ea45dbe8320fa803f9767ef2892465132b2468fde10c83c7de2899b183305", + "3e1cd4a96a3d65886666d8639eaada205bfc562ba04c753aff67fa7a51f0c076", + "9dd93f4fb4279fd2d86e329d9b78dc233522a6098a2582e6cf22b4bbf6ac3aca", + "3e74f0cccb4a5887af73e9f606e42dc44ac9d4734d1e19b6864d363ca8086bc5", + "ca953d65afaec8f63827ae649551c445c23e946945e0cc161caa4049f9cec9da", + "3652ced8aedb685ddece1befd637d57672d6bc41285088cd14a2ab100b2449f2", + "37653c589ff634842af4f453f56cf056e43c0b5afe948ee41a4a8c6e92a15f1f", + "316ee529d1b45580135dddf86befef3c8d28a9b1ce7bb597bb77a07611fb14eb", + "5ebee7e298ae8dfa62a8aebe586ba0da4e8092e9b4107d13953922eca08007bb", + "0bcae0ea7b353dbf3905bf2a4d6de2fa2b757d18e31ecfe6440961f1063960fb", + "ecf91b393cdf1121e91067b7e8549604347a53054af0582b9e0e68557159b710", + "44763cc84d357ed1eb4785190ae602956a2056c26dd89191c7b4a916ac18e531", + "2b4a671ad90b727df31d7a5b5150c803879aed3e57b3d3985c7448a76895bde0", + "f30b8faa2f0c5c4b2967ebe9bc794186875734bc1f65dddeeb405160d8befb73", + "7326ad4e8274a26960df420af11a51a5e86f62d92dbc12c450c30e7d47763e12", + "bb6ca6b5eb0277836123b50ce2fd70fabd2cfa017aff14027f3625af8108ff06", + "84ae18fbc334ad45555704f620549e2d3c06f328a6f9375222244529dc4f7cb2", + "481629a712a1e7f0d589280f76f945dc501b373fa433b6b5798a78f86231dab2", + "2f9fd05737c9417c929f9a89bc1e1967bae8f799e62d71834d09e86bae52401b", + "73d34feb9a00f4023d5ac83c5685ead8bb01b606249a5b4415b901bc9c237273", + "74c626b57862591c77c3e237f47e1c0a5602cd4b02c90bdd74f11412db6d765c", + "24f94b9d7488c6e5e0132beab13b85dee2bb59ed1b7fd56cadc244ab81c8e0e4", + "af42625aa53862893c6f02fda04cf71ab41aafff641ee5eef83c0a5fcae4c621", + "9c218f20c7487b9a1b5d7c81ed8a6f0657c85cb3f2970eb09a7211cb57040542", + "cb18a58790b7182b0ddb73ea89f3b04fc98354e682317b3d24587b0122d88673", + "1544e14b4b29cfddb9e7fde5d417198631b81fcc0e197f8da072aded648e5f71", + "3869c6986f91e7237fbd5da2ec9d771cdfe85f413907a91dca8ab1801fe202a4", + "b2d90d67c95626a0c2a32a344e47027fafe9b8f94a08033784d6cfdacad05160", + "47738234316dc5ab5ffb07a61c8e75f4b1763c2f971a82094104892bb09cb424", + "b1a4d674cf19261a45c41b9274d636859946c4072ab04030372b350fc097a2f8", + "93ed266517bf2658cf146567c1ebcd8fb665cb735bcffc9e616f8d7cd4d3ba84", + "85ba2b142b28c234e97fd68e96275d9ca449ab71918289e3e3065b8604c4f8b8", + "47346fedceb37cd8261325c487894f9f66e867cd962c5f489964cf7be8f8ac25", + "c79e89d993ae12eeb31c9e135b4b69c858174b584d9c970a2903cbbcfaed1a9f", + "7d0dde9cc945723029533ffd579318f522023a5957496d3406320780a1faa5e0", + "885b435a6a0212724a3ce82477efa7d32792c5b6798d0401953d486c5d3fe7cf", + "6fa7bd820f04e821c0f7e6914f316d55acae44398fa8641d584c2e2fe262581a", + "6a4819be75da11867123350c46bfe9a32b960a8e9c0b56c5f9d21d7f40a25ea4", + "460afc9d5e81e6f86212622dd8c502e09d6781348c60d088c59903b47b5cf916", + "99e613365d476d059c7b6a1117f868bac0d7d7bbbfab7217d22ba01c2b0f868f", + "411eacb5e5f7538975abb797c7e470082d2df6626e7a819746d721fa8e5221a8", + "2b6715c2f665f6848c84d5597e9766a3a33d6be57a61dd217f6c78600a526391", + "1deeb9a65d83d394d64ffcb3fc066758040ab92d67b8fe2bb82d6224805b0298", + "8fb9c717886d2475b48902d45cc366924a66272dc6ab099ab5401be218b7a73f", + "fca0e139accaee6112e2369b8d259306c294ab65f5b0c6c5eacab11a5a525663", + "80c1d0c60506dc98150d5755502fa6622d7183944c974ad1dc7f1bf7b59468b3", + "c1d905e457e3c2aaf3c2158a54add8129ec9b9e7016aa1f624e807fdec87196c", + "3dbf1076254e54cc69ae397dd0092cea12e26e87aecdec5902d63d5a246f3b86", + "09863e2a58af64ae0ecb0a2306a56c437d18d2b76ce3d7dd10a3edd0413e8321", + "fa4bdcc328d70ee009cb637fba005492f40983e812adbb3e63d3cd7902d278d9", + "915771716dd661d783537a90c4876af187d00bacee4f1128d6e895ecca2b59a7", + "0918fb9a24fa7bef1791c0ddd35730e3b5f8925e673ec6fa887459773a54065d", + "8fbb87e9231c93e5fab894a66275028b38545eb532171ae695af7f0dbc9e894f", + "ba52d1a40d9f9bbfc45402f18c829882891347339fba1ba8d55d319731121f4a", + "8a8a0193717066664ec4b9d9e3caec4e418872dd032bda745c0414b13a7487ad", + "bef5aeb3aeed0c9f9ceec9fbc8a5d3e7b7f0c2b29069e13a252b12ab51b3929f", + "cb3e08940ad32c21669273d1d1747b5a47f950e9c75ec38562ec516389c76fba", + "ef1f228cd85498c252680f78d3bdf8393bdb90be6d95bcd59e7623bb40be050a", + "9f355b270159b83511a9c2248b4bbb12eb6e489aa3a92ccf6c29256e6ea9b06e", + "6437f0b92ce92c315f2ff143e19176534f033b7e7c8599f6e1d3a56fbc681f33", + "b8ddb4029e5829c9aab98c217e7d4abb1805c490c708c2e29d339ce71e59e5fc", + "981e3b36ae9d61d79f4f2b38c13a54a5fe00788065a91cd366fc8661c0c8da5e", + "9d9d43d9e7796477ba9c4e8f77a0daa92183769a182d0e396115d54e4fab6ede", + "d106799320cb137cbdbf8460b8dba4f8998c46a5e9121642a826bed674a1a811", + "f76dbefa1515c4214e0125d111ce3fda41d2631719c41f6fed193460911ce1bb", + "6b3ae881e96af61e14abb7989a5f68928625472bbe93ab1cb8bc7ea12c984355", + "6dd2459c3919eedc8bfb117947119ff2e4fab2af0c395a99be20a4826ca5b997", + "935c3fb7b0262e9a0eeea69e5a8a27a1532c04f7b1cb45d9e2b706cb71ee34ac", + "041d1ca7ff58a8861d0771d760f9948b02ee0f3e67ce83ebd2d8d30d04d15a4a", + "260d511f40b1dc8bc28fe69f1fc428a06cd13b1919c65991d00d0342bce5e3bb", + "ddc67a61c154c96a06f866529589222eae778211155cfe0612e4ea21632e7647", + "39f9b04ff6251f6148647c056e0e39125e215d5120f8d7140eb90811ce4bf3b3", + "8a37cd05d2ef305fef2f5922d739a224427017171647ed412daf30c6ac950fef", + "fac0db76463f5c17c8cf5e0a25325c0b395017f97bca360bf609e2b674ec0222", + "3a3a279621e164e08fdff6cf82e5c77d91ceb53c4f233c7c5380d2185a45f609", + "dae2779f605d985498181eaf155d7ce98bd10db46dee5f451077aabf4be26336", + "77164eac11fd52ebdbe9803bcfce144e56dbd05de2142209353d2c0971e6b69d", + "26036bbe05466e2ba2a4406e6bd6a0fd186fd7b5ca68656a26a15fee2e7384e6", + "f8db37b06dfce13a033d0f33132ceccca74be4c054de02d5c57b239c3638806c", + "0382ca1d7acbc9006104690f41bafbd74f3b2689caf74d968f807984a0788e00", + "6735e53abfa93e479e1990ab3aa974326216bcf2b2372a6de893eb94e36ef489", + "9c4f793d0d477f828d77ed1f1f528c8260bac184baea2c43a2a1b34865f171e2", + "be78486affffe4f57015a153c5529c949aeb7511e1f30ed76da522452f245bed", + "1e956fd0ef6b40427cb12f753f37fef0605b0636e078c9b88b82c456811706f8", + "c7a1228e669270688e4bd55ad6302e6c0ad0b2a51be65c42439a3f5ba62fee3f", + "bb48cde1fcc94f514d1f9386e0f734e95609cf48e91cf82e682e55b3b6118394", + "2c2efbeafaecca771596b700c82fe9f4b3cc2f25963e5e9f29211a12c7709e36", + "f0b30b783de62b4c7516f641807267a0a31904498af70d1a6b29cb27bbf64cc6", + "565978c026b1ebd3159e75572762cdde0f6f84aa6140189e72b16195ddfde7f4", + "9d00f95148f6da1ba980b353a353ba8004328055b087e55d016ae97f6ed7d034", + "9b115ac71e0aadc1a667e5453b8447eefcd68d9e7ea6c0e1abc958cd7cc9a6e5", + "8b2f332e97657fa5ceb5f23f5a18aa2191f2ea2c476d66c10256f7d1395f5df1", + "15837ad2725266a35255f91d2e023ea644ede5cb9d7ec9270ab3c6dd6449a74c", + "3c394d3df5fa6b967de6e972d7fe4830cdfd015f2f1b757ce278d16ab74b322d", + "fa0fa7930ac74d5df155adde0bcbb0ae7a27b3447a22f484080accb923c5730d", + "ef2281473fa40ed980219dd1447f918cd9393b9e424005851a019c23c1503cef", + "fcb0233fd9dab90553f63989f61ae58486317c225a408d815ecffee9c56c88cf", + "ae480841fc3601d1a6072ab265529273b6a8156d27262615741d0434225dd56a", + "6a15095b54d8e93b4efb605250e59dab2725f9351fec512daec94f6dca814997", + "58b4af6862291b6efef9ef2d31540fa37ff7e253f6de51be2257faf028148f24", + "ca6f15144bb9c8793d0bbdebe3ddaadbce8cffa2f3a7bf0186c926eb76f7476b", + "bee687ead9059d37f567dd333ee4cf0ff2ece3b2fba91404c57965b79ff0339a", + "7bc97c8ab6c07fad3a420f2e86ed69008fa7e8b97380170d08a77f33ce81a039", + "5fe750b9f9e3544656c6af4a0733619a0db0059291c1dab7f9250386daa8ca96", + "e1ba601807a9b2ac083e7e87eb2e4df0b36158cc3ef1291bcd25321a408a8425", + "19d29ae989ccb2a510f2b29b5dbea779ef4e3ec25b97e7b21cf799624d3810c1", + "a1847d35183d55d57e57bb0775024a3ccac6234de8d6bd09254145597debc251", + "0e3658d575a7276ebe01432a50770a20750c951bd3eee9fbf5003dbf1f860193", + "a16bf2b27ab5f2bb5a18cf542cafab43101da5fca1e717a17cb128dcf5448943", + "a2c6d226a587f3b828730f12bbcf7b32a6360131b3537f87b51e2557586ad598", + "ccc53f000d68d160e4596d6d14097aadda8db7b7595bf901ce55f8e50b4902d1", + "7d7f55ed7ebfa9c9dc44cfc3062a8ba90efd27a5067181ca339a8ec8a83727d7", + "dfa6b6c25afd247316a7d0f37dbf5421972c32683f0d830e96315ab51ae2a834", + "7e41f46b0ea99929f67b09aa7ae4cd155ee1c1db791b76814db07be203d08bc6", + "1ff5d1d68f3bc11c66aaea4d2f68dd435f9026d1cca7388cc546c2151f3ecd35", + "42e0b42aed3d6bed749412693f7526cb06853f122d8bdd77bd17f999c9fd2820", + "a1c9e8c224b0eb22ff2c9f3fc28bee647faeeee4ca8fef813b99b2fda3718dda", + "e53088f57a3734cdbe5bfad94d111527434402712d8af8b8a3be904ac40ba2b1", + "34fb76eaafc3ee432fa22def70fbe92630fb020659f9e0b63177d57146f50e2f", + "f5ddfe4482b311021a88912aed1d78e7748f6c971dcb713f013f5f0a815f62d9", + "8f4ae53930d528864d6bd7808d32c5c14828188014b20b2445a67dd605eba5cd", + "dca8d544dbba450d9f9d3850d12f04ed3b7a0d9ad34d927a1a0debf359ccbce2", + "118b0ee8c095f37e08b4ab2a90714438eb3e117cc4dd089cd38272bdc3c07bdf", + "033b85512e8c09b4585764284e5adf164552417a9ad3d555d8e86a2674977c5b", + "74ac9e28c971a5e85f53fb92796f6ecbc7c0b53fa66f0f386f5a580a2223a8d1", + "ec85ebd686ef0be5eaff07adda00d99079d499e5d8ea6fa6109e2e3c6ac952f8", + "5fdbde70666870dc3254a7af099490f89e6a1c8568e8874c2088c037b06b4c10", + "9a9e9020b919bfe76fd84a2259c1456b7cc898b05af56fe3b7602d9b3c2bdeec", + "1dadd9c7b2bcbba8618ae82efa38dfea06d448ec215e4d5474c8d0c1416b9d87", + "31ad5dd925942673e7172087f5098de93ada8e110153df8dba416dcfe8a5ba93", + "2c905f2acd27f903dd2e8b472acc95591dec08822365f0601cbff88635fb06ea", + "45969a505222444f053eb9b02c62eea133be32ca0a63d01b28614060422b3911", + "3ac0a148fb1592b5a7b566939fc4588f9c0da098c601f6aeab3f933b9cef4e98", + "72980a3c39a6abc62b1d4e9702f02ccc473d29fcedb076664d4ea7b455b952cf", + "3583b919fdf433c1a1aa44849a3eeaf47a98eef546b6c0dbf75938c0ee60ea05", + "802afa4c01fea455ba593b54021f1c18c5c7e262c32365d888972ac1a0e20fa8", + "049b57a16e45f5c0485fbd4b57f34341e55e5f7e00f314eca61bda0780ed9b59", + "3efe9327a4d9b7b74cbca06d7c704dbffd499a7aaf81130b8c2a03ea117c2d19", + "722620f97f062ef8451ff84583174f1523fd0feeb3cb6c673e7ffe8b26bc9c8a", + "d5e69f7288e56c05b67ae84e927c37acdc650412a694f5a67acc5a8fc22d27d8", + "ba7ddaf72f0e034da39b43276b9f418894a12a6fffdbcf6359a302ef1b34688e", + "5b65aebda07711f3b75a7e893258b7ad2d99d8107379e798fe78088b5041690d", + "9c5554433c25d0d360bece8bc3bb9223fc87380efc49b7e95cbda1ed6428d0f1", + "6ae31d5c26d707204d4d5afc3d4b17e01f0ba880da52b2be3ad6814b71f0897b", + "1de6d1daa1201e3c144b287d8f68b33747f8adf370969d1ef4b782120ca7e0bb", + "101548b62c2977f72e24b4fab110c3a956f09033e0aaca397db9f88e9f9560a4", + "5b39948a15013bbba67623e5da66dd0a15297c7d3e5adbc014c0c2a2892997d8", + "129d10b8724ba2b31a1044dd610ce85eab45798ebd7351f04fd05e2e997e4472", + "75b669a54b61a92f39d714aa02f64402a17870601b9b8eba29547d9b9e535d9e", + "c4557744f0b79b5a1747199f2b136eea2e2a8fb20f846dd064f5b0527be2914a", + "a088a61d157c11d9a228434ff6dc65ea28b3f950e75cdd6ad74e601333fb0477", + "44de5a4e2919c710639a388a185bff622b81595b8d62e874560c5f266082bdcd", + "c411bbe50d966a419fc8fd04327f1bbf6e37dccb12d6a38a635bfa8840787ad4", + "fe1f09ab7acdbddd0d62904a8a9ca18fa7e683d634e2bdf52245f700c7e817ec", + "7fe87ac755bcc31acacae4cc2cd3d48e1fe758df23ac23aa3b7b2560f6ecfb24", + "82537f27478a93b7da39b997061db33c8cc2de0f4352b9236708a02b2f9b84b3", + "a33d582c6d30bff71174fbb15c2296726b47110512390572b55c40dfc075859a", + "a2afb4a5dcb8358d706151ba7d93541ca313849cef7b20ab326f03aa508437e5", + "73a1ef159fffef5fc86e1b495251fb6c389d81bcc7c8b654640e23a042f60a01", + "35020eff0465c3451f0fe001372cf28508b26fc1494982edaa86f5ea1f2d8e8c", + "f7e466d813818f5d58d8f36ec32549b2f4e2e426332b74aac155a1c7e64e152e", + "daca2da778735d6c998fbafab0580867cb0ade2edc54cdeb264f5da5d7897221", + "b85f0ee8c73d1ba854550e337fc0366e30832033920407ae102ec5b6d748e16c", + "b9423049f0c08a96b4fdfaf264a2715fc8a20535a1a13e30d1c6fb2d7ba3aa48", + "810f634e5e9ce2aefc4a9c2b677deed287a18177d45709a92124c1dfc21c9c08", + "32c29482faf42f5516c22a8f1cf6c32ff786c9737cb483756efa3047ed84568f", + "15440dd1ee8c6405502efce469602aa85bd84441791aea9281d94e2c09303166", + "5b7fc2aa2037cb071169da797966392053280ea57f8b5a47477a2261d7e36d8c", + "7fcb9c56f281681c3f2639cb8cdc4932496366663f05718ba84bf28242db55d5", + "5785a503e32947a2d57cca46c81d050bd96f5e161f6b3fa22f257a6b63ffea2d", + "083cf10fc69620b2c9b6fc87b3fa951270812730af51d41a76c26a3d94f3a454", + "407d3d8ab6c58d2db63f3c496cac5efc4c426bc0aabd21e4e088932dd0c8aa0e", + "71aa71213ba2368f91cfc7fda9a21422827bca74e645709db17cd3e211891c86", + "4eb399f1f844564bae1a4e2a227caa4b279c4eff7e98f9329b07fc8df32671af", + "5f77d90bc8918f2ef60ccb4704f88042e844a6fdac00ea04ae69f68f8639f204", + "0a774c4e2beba82459bf3fe4af06df6b1bf7b357cf0228a165b5ee9a875c6187", + "407106e868c56cc888069b941f445955f0176f66c5c7d1581095cc0fd3c21cfd", + "3f6816990d768e729ea9ede1e9fdbb5e9127ca8cdbf63ea12c8998246129a1c1", + "fba0a480a4335d5e92153ff7d03e9ffe46a9e4ef4bd54c9bdd13bd969ff2c969", + "e271b513347dea314bbd0aa9678bb186af2cd5f795ebe88f1302514a5b5c3f97", + "63107e5c9e2ee927431bc9f338f242ea41c311eca08e79e577526b1bc2731184", + "ed13aa7b4873ef380b42b46320b3faa047980e2866696e2413ab30bfa60e7214", + "6da92b1b6fc135a6904c71c00dcb956617b5e171ce98e7b4ec0d1a2dd37c2fb0", + "d1a642e9c190e73917e7cbc268988f556779078cf561a5517766f84474ee7822", + "28dc26e51364fd1adede4f774332910ec4bd8993ff357923a7a0a017dfb97f9e", + "9a2278eea4d1cce0722bccf6224075a8f907357853fecfc9934eb0f6fc233e1b", + "8dee52edc49245a60a520c1a52ba1a3f0cf31ce315fee3503d443ad8dfc3227d", + "67ca7371b3c5de7313a39c94a2f8d151417ea34817b982d71d4326dc3e234641", + "e9611454c885dcda36186af633052f8f35756c6782b987132a80b873a6fa492a", + "1263e41f4484ee5f92d27601dcf5f4290e3aac3bded971d3e50d07d89425bc42", + "78f4ab6f4c7bfeafa592ea2e2916438fdf21e11990ee505e99d6feac858c419d", + "f253da602210b0fc28362f017473f23378f36d190d4ec9e9cf105c54e43d1c9a", + "647c20162d2db325ebf8e71cdaa0d7c06e01198d0b23581a228ac4d216e1665d", + "920603364021701350a2708ef788396c79d2e2b7ae48519bad2b09beac27fbbc", + "7537ba60fd0462809ced9a559fc5c3b59f444113a25370050f7023a4d7114525", + "6b613959782aab3c2f65b8dbb47aae388e7115bd2e2b59de362090c048082de6", + "cf78f7cd9e14692b92dbf6bfad5c67168b8ab53d1e358b2120b333eb233df1d8", + "b55a4dca50649fd4e4dee58b5b250f8768fe19d43804f5da1a3b6c995c8c902a", + "f10f2bb9ee6a70ae8d7f562c878c186e2218a04f2779c2ac54109c081d16daaa", + "f7cd919b5d35d35d430e9d1536105da9c082dc8a952811536b330a4d4ac1a260", + "a6541ef468449e3c05e199351cecb17c3e2c6bbf754de21005bb2ec7df175676", + "0a9385a59f86d47ffbd5eca28f613b8506cfc68dce29ca9dd0533fa96fb759bc", + "c359f7ed5e4a168b1e27bd1c27dc9752980103a2e1b38991e5011a7ea44d214e", + "da696073966e5f987e38c54c8117a921077c2bf26faa2c5207fe65bbcd61fd9b", + "89df9b912480e6c8a096cbf9e86a706bf1857a794431a9970f2c4043343b22fe", + "e4d56b83ba333a48e07d0fb82ce5c951e84a36e17bde670f49bba7e8f76deffb", + "93caf967eb5be0e7700fbec9176be10f6d09f64af8c32b691d1740c247f08269", + "f32980bf904020cd42532d2c16795204fd4edff4db3567e207bb8e23b26c1d52", + "54ca39f054af2c455174e4f9e8c85786e916c394f4edd1038aa2e28a0bcad171", + "1127ee833c972f00c1a9d1b005b725c4d99b0c67de5945c03f1f724a7db43780", + "bbb729809356522febd6a58d7c951f31bb900370b19c7f5a0fd69c1f122d1f6c", + "028d1efb0088ce31af4e2cc67bba0197cba4a0010d0e37f79ccb66d7f2d4982b", + "10307866ab7eded36b64fa736df25061fa5ea5ab743030691a9d50ebd29a71c4", + "f05f2de80509241f391f0556314376dcf5691cb6527d422e91c7eff411181d8e", + "bae982a385e4c5d64d94b3f52fb7f279dd412aafcda0af957d2f0060d60c531a", + "05321f995ba2cfd80d2ef978c9a07ae9f25e419556dde704354d797d6c53ad75", + "01f33b60ec0dd00b4e21ad4922ab300a660897ac8f728da6ea63afc145967446", + "345f259fd8e308a92e94b7b6c9f029fea1266470ba9ea6311eea519f18ddb65f", + "43c032e89cca4d98bdb51b8206ae27a907e47d97474ca89796dc919e392c8000", + "bfdbb6a414cb73486112a52a27a339279da4fbebd6fea64fff5666d8fa499b25", + "b6f174a9cd90b6ca4df4b00144fa7ceb37bd7bb5525e29083a77f02988e93cfa", + "31783102351f5d1c9e94c643b70ed6846259c3f75c401df9340453115840bbda", + "6225f386d6bf5a43e0552122cb01a3105b1d350b088dd9ce22582308cf05cb74", + "51c0642604fb7736168fac0bf66723529dfd08bad84d1495d96bc34c74df5c78", + "35a83108882fec52a6ca1424e81650ffff8cee65becbb68a1272fa0a508becfc", + "7428b0af8a33dd6a8c825dafccb48f1de992925bd119af569879c3e559d91035", + "7e7fda79ad0da1ad6be3995396417139fe3e7bf47850d13cbae39032b9df0af5", + "5d010b20bf9371bc10ddbfedb9a043510398c304428052004a52237e8c3bc04f", + "1d52d3e883078b887ee53a3ca435b0ad8bb1c69657eab441f7452ead603c3459", + "3ab0771f44260bd18e305595868691d923674b15760a449b00eae527b638ebf5", + "ae6eb20d4b1724d917356b69ade9b1ea8fc70968e753f95476c9b3851714f8aa", + "847912ad37a6012e986ffbfdf0d807aea66f46530e89fd469ac82fcf74cc518c", + "4fc17a34bec82d3ae2783decfc5c03e13be631a45f86306a38ec11e43082f2c5", + "10988e08ae7beac5d25a75a81afa670aa51ae8eb01d66a0bef5c94772d573cae", + "6ad7285cb09fa2f9ab40a7f1fbcf26942d0867d473788d5657bbcabb7fd7efaa", + "5c0dbf72df4ac137228f9d139d83f59405ea936788fee2b2306bd08a6b3e5dda", + "aa06843bee81526134f69dbef54a25d92cbe5c9b504bfa705bfe1f703efb5d56", + "e90f06b97533da5d4d2f262266a9d2e25cd4d1cb5993697a2ec8da6281482fe0", + "edc7bbd0169ecf6d3771451a71926fc16db27468791eda3d7f310378c3bfee3a", + "eca228cc9aa1ba55cd28988bbc531f6a26148b1c8ef9700e113c069e2ee93892", + "c5fb85376bfe9eab1eae1f407393877ccfd484a51d24f62378a020a8ddf6bf2e", + "610c10097207e5ab761b4296a975518947fdbb454f0e4ef1296d98c7539d41c5", + "a465b19b5306507e98180afaaead5af1fa13917a911a5f307576307d0c35707a", + "f97912e1595c55ff39ea3acf27e04a827f930ab9ce8061e3b72c533466ec8d6f", + "2ede1274799fdfb6b6bf1cf8f51681c08e99436b5f12a1da463d6fbbb9b47d69", + "108ee235def7b885c5b8e85442022bfeafa4019d10ff4af36dab0d1449e53cc3", + "264c4202708db1774a54c377382cb48929be8a8d658c4d790ffcde85d2799a21", + "a02b9f1af9a2009a5754fee7f82277e016c787814b8a5f8641864085ccceb4f9", + "a145c513fb4f0c033389bdc165cd07b387297169cfc054e17957d4c39ad615e9", + "abe0268291b2661b5744cfaa29d58f60bbf8ccbf1279b334e008827dd5f8a40d", + "3341ef488771c2804dbd9b5acad462cf453cbdcad867fed39c8c3d7db800f7df", + "44fc7f0798df5bffb199883fd0d2dc7f4013dcfce236087318d5716872200691", + "24f902ae7fc59e7331ebf94fc8312ce65d7a845fd89aa5ff602d0798988e61a4", + "f5d3fdfb2400deb0cb097fec90922423b474832dfc2c43f5b7116abc814e37ba", + "6c9a97615435947331d830ffc4c5198528003c9948707c604daca57829a3f2f7", + "75dcb222c0a503df9a8af953fc8e813803544e863e516e9b086db8e39a4456b5", + "1e7727ac7859e20a72e913cf4835f4096c09ac0772bd5ede3e84334c164523b7", + "aa811238156b0273029d2e63471770c35cc47193fe3f7b4f753995aecfb06b4a", + "f3a03b2a1c2174ccdca48b2adda9b60b1c696a898a0cb212c1f1eaa8fb53df71", + "855ae81572b1ec00269fb9ebe9e06feaca58a74a1aff5f2e626b60785cd13c35", + "f28d6b9e51908c546ed5ce3103183164bb53ae95a5ac153bfdc623778fb01155", + "2273ce151ce886df6dfe304109eacde8e3bea82e42e2b0e7cb9bf35481efcaab", + "15051e762dab774e7d1a6f0f30698f932b2c635565c55b5d68efeb675f725c21", + "d9d7e941c3f1fd68b6f6cc5e7e442aeb169010fc561b912597675b4c82f33b32", + "2b818e3d05c926f3acedf53ba1a020eb6c120f101da458b0b502eefb54170115", + "60b819d14f8faf5fb8f0557f9ccbcc48e7458df995d10ef0b92e8e174c313e01", + "c590e6b09bc2956e38a9eabbeda0c39eb10534f18519b103451f35641abe5656", + "53169004e6424b9769a498ed8b4c61dfaa809baa26e7d6ebe0fe014af99c4770", + "3b9084cf23e63bc5c8b936f7e97d8d840d8cc1112bc623fd4bb0721df796b67c", + "3d89c38efa3d10019fe8ca062161e88d572d56423d350529c01252e0be50bb41", + "441926a4665948dbd3df7acf44a4cd1fa5c6e3bcf3586843ec789c3a5988266a", + "30a76151dd3e2de0b82055d7ed05e7a37cc8d3608e2f858bbfc0c76edb306a78", + "e6d3761e3b6bc3367035a20f4d03e6645f4c33aade0f9ead6f6b504bce243ea7", + "77f1ef7f4ea1ce5e2be0b489556a343e431df5c1ff54022e1cf5e3be75f36487", + "e3ca39feba58d201a78af3756b5f6c3a849161caee36e3ccf14cc473459e8d0f", + "716c4c76867143759e8c45ed2c1e53e10ff79824185f3617902e78958b78695c", + "91f34d3be5bf4b9fb0cbf52a6565e4d1a5145533116c92c060b36de35635376e", + "407f589731122088f8cb7a170c6ac090c93e14a4a7ce9d460d7881096306a473", + "f1e8db4b26bad99ead041b7e9d5e2f36fe708ed83dc754f4aa74c08077334be5", + "bd343ab972a1bfc4de4cc9338c6b8fa246f996bc683d1c46ae801704eace6f59", + "3ba0117ac10d1bb951ee689f3b1d09c40d1686eed462d1b04839ca49f64b5c96", + "44e2e1b0e9a284ab0469f130e6eaac49632e591b1b00a9a37b6c931eed0c474f", + "489cdf50880e4d5fc254635d3211c627257e3d2613f426353ef54775669c4dbe", + "12a47c6d3dedbb86cff747adcb090026e4b772396f8d58ab6566768967813b0f", + "8492123394ce74946ab0a7b5b02280fe2364985e3ecf1d6b67f1c3541363305d", + "78e84d283f4f661b7a5f17c41d9571b0467189cc9c1218595f8a604b12a197e0", + "5a69a1aaf348618d5552e167819ed8ac9918191f68981c1c479d2d23f35aef26", + "3ad799126520722346d2098ce8c3551c1402a553cc3ab1fbfa7dda4c2083f58e", + "bd05c86769cd3c6301624e43c573190148da4e289808a9197e4dc84adcfc2178", + "cba04afe1491bff2f9159cc15441b48170096ef4339e52d60e4e901b17141031", + "8d2604b456e29757844f332d67e4cde6bf7b65f16fa0a4fedd6c3faee95a2a68", + "427a65e03a3d0470236ce6f4fb7657a71bc4f161954b55fb9d38685aee43dabc", + "18583b7ce1ffdd6152d9c33df40e2088faae349245dfb33252e49ddb219c6251", + "deefd800abafd099f9a0369ccdbac62d63edd1eea8c9cbdb47f7cb699d5379af", + "64de571f96048203140e04812e8590af18d83a36c931bf1685c89f313a4810ed", + "6f9869e9c729060fce8fe50891b731f028c6fdcba1e67256c511178d949064d9", + "9bed84e0188bcdf9fa0093bc18baac140f796e86781e2881c8ba83a38820f346", + "f6fcce77f0cbcbbccbce5f5d1fff74b3602454d372a210b7798a060a64407404", + "a860dca50450a563db74bcfc55ee0970640442bf2630af5b89850ae1edc5ed80", + "3ae0df3391fe1c0dfed2d75196309c440c8dae53de0820fdc4e17c0f9792322b", + "caee102ca96be4fca636a166fe18a43b4d51dcc2378092fe89aab8aac340de13", + "16a82b3fe100c84f26ae79f7effcad3c724a76415bd9a23290dc7978f1f3446d", + "21120542290ad8b32e700c9adb6182266dcc55f69bc037875b24d358083463a7", + "acc70578c3f6e8048daf021329222978bd5b41015317e84d8085a163a1f5a523", + "b32c7edf817d4a9e3742c89f76640446630b36f4487b842a304ba6f6f813f5ab", + "aa79e1d85dbde840090f7a8cbd25e60ada36012e87d18353c1e52ecf00e7fa5e", + "06613f0de853122abd644a4c3dbee1773404d40d498a6d0491878affc4f7a454", + "449dd10d24d404e36d1e530acb14883fddab84a335a3b276d487697bda89f94e", + "1128ef14328b6685b0343a90082536c980391e6c3a8594cba2d76d2ba95364b4", + "903bdebe295ee2070c2b45c56529c4cecfbcfd85d8af62e652e4417443a857be", + "21a685d80b5abb56473226d40353eb72e879d0b33970ea4abce8275b7b7e9970", + "d845667b8654f3116e4c6060eb933fa691bb3f7e65b2ca0081ca06e9c965b3ea", + "8f1c1421eb33f41d8067870e1566515d99469cd52df65b7a5c38bb197c3e0c36", + "153057975cc119ba141788e324f7a52338e3d36407ee07afdde53839743dbf9a", + "85ebdf3ad8ac683839ca3d26ab8c63685e19d1af0ec8dda452a9f6240d812d04", + "aafd8f6c7458e2a8f1c9f148c76c200b9a9b135337202cff5bb48ba9c917a7f0", + "cab6bc874e7d10139ede9054bb53fdd6565f19eb577893e6f4bb404d051543ec", + "1cb1f909176e3ab8e229b466c9e27468d57cd8e696b43284da856dc927d87ac2", + "3c74d9ce1c7e90dc761ff59b6ff4889c08c25cf859a933820e2c6778f3f87a01", + "18d01c53efefaaf795a7e49948af3430c766efa591339a373be6b794f1ad06e9", + "31bb82e1a9d8d81c1455e7b0a4e8d092339488c3c44a2f8ce0ea1bc7e7791dc9", + "580647ad8c108c412f99e16fd60fa0774f0f670d547f5b85bc3342bce9956825", + "6e3af4352050918838c0b8d4f18cd5f636d9e701a06b327287da96c874d42cc2", + "ab7cd65e86c5213cdf5f1fbd3b34b1d803d9d6141b1a5079633d962aeae5c0e5", + "535843fbf06751feba5ce8333db04f9358204171b4322ae2b4b5152ddf96c31e", + "1291df20ca229095ce11da54804a1eafab76a82178c2cc3976ff53f252ec61b0", + "c5a486466cb88fad9cc04f3ce3840b243493edcac08ea52759b5cb22e9079228", + "d190906c20d4fe2a9445617e3391e504b169438e98a7bf3ddf5547241f6c9ab3", + "ce70d0b0f95f815435804b18f084eb70630ef65b95663ffc019c8cf82e32fb31", + "8855373cd52bc76498cfb7fb3252cb73281ae66d1ef74db08abc154048b3ef37", + "af9f61f563341d54392a82249b3306c0af8e9e20d8216f55adc5e09a3608433e", + "7ccbc570c1e857ac0fa088ce6f6449661a6176a41051ba22261efc61df02f1c9", + "aff3cbf02de866336dd18c3223bbd79b15df92f4e2d232d38dc077eb940951ee", + "d1b23b78c916dc2d436617e11105e06aac9a960224c16788f56cb6263bd73b9a", + "8ce93a8135dffa7c1b62ce11af88cc796ca88f354b1393c2986325b32c8cbd1e", + "77b6a6ebd06cd965d6ee409ac1b9b3fde08d8074d22023277b3f389a89cf5ca8", + "634c38e8e105992862ec1b22d8d04be0c4b7235479dac76139e100770ad2a6d8", + "9c872c70ab302c00b016791a73876db8883fb84ba33573eb8a2668c14bac847a", + "60dca31ec81c69d2cf9278d5171928e4652f768701effec4addbd35c918c480e", + "ff80118317aac77149d766aa829217d18d719501dacad9488f8996edf571e076", + "55fff837eed4bc50b5276926cf2f0b8bf7b1d03ac681c323ce64fdb32f939b1d", + "83c8afb9bbbbcd2697827df9d4e140446f3a30f7814596f4a9ca6ceb23b2cbaf", + "fe986788cdba0a37ad646602197fecf6088d06a431145c82b62bed4ec73af7aa", + "26940fc99ce63c944f26fb40072a010776670bc5ce5a0c980982508cc1d8fa80", + "e5978cebedf2479f5418b7513bfe84971cdaec1a6da8f542ca96b73e29d7487f", + "9ef74c16e3184f55edc44fccf3b8b5a233aaa984308e0a0bce41699e7ea4a030", + "29779b4df1917a3622031d582130d0e270044d8536c743cbb32ac67d2623e297", + "424a5488bf25a262dbe74d0e7cb8b16a9f00e308bf454b87aedbace031aed016", + "e80b995c6cd62d576f3e70e746f7966a93c7a3dc5a4ffcccbdffae1eda80dfdb", + "e0fa251236b31126c28fe8b3b95fdfb8ffc590c67481f42e8263ab7e2b296d73", + "6a4617df8983276889ce6013e2f7fe3b1b0fc4d6f6a3167a0b3242f969067164", + "802551c1d13202ac6d8ba8d4eb33327cfed8ecb1b1fc71f2ae6a1a05d6631206", + "9fff47d5e452dbafd22ece05da70c4bf1b024092fefdbea2aa9443132118f318", + "7f1c92f8efbecc72ff5a1e1c5ec4870f4f9a852a7c5541b5779d20e4a2800cf4", + "dd7a849c1c1a0e75b884a529dc14b0dcccb96de3ee0c1854b883c6c891c227fa", + "cb8cc0deec4ae303338c4885448f0af085604996d61359534d46cda8dbe75abc", + "e261bbf46983b8a1b0f65b6f1f136f4aa40b04ba7944b8039de015d30b68bcdd", + "e60882aa61e6012981f29a5118b503b9d48dada4218f77e1ae57bf70dfa0900d", + "14c8d92f8aba3eb0c84c535e1d3e01d7a005baf7a9161ef085f2d2c37bba283e", + "4841f81014d2c936c1a63a3c43bf98e3ff015ee084056f26d1c1b8c71514ab96", + "d79d530b7bd2f0a3dc8f0c13c3e0c41ffe8992acbc74cd7640004cb6dae4ba71", + "2770f686921772a20d8a3e372fc2a3b1011ba64ecab7d10b9b7b7b08cd0fc53b", + "d618f38c0b2f73bb7985a1f07a7b4ca3b70e62a96407b8f6877da59e9241ba82", + "a42ade80310d49e8f0815265cab30124c93e6f0eb30d12bc031abd031a1fb63a", + "ed5f84568182e3084ebfa883e67706aa5cbc40da4e1f3b1ac31e83d199df1e28", + "fe65e104c6cbf94e45a3b7a4031835d60266b349c4822a5c428dd8165540a969", + "93d4bea4a2ff42c29ab39eb6d591c14fd0e256f276ae22236d1a91a0dcb02a69", + "aee3a3c773ab886688a170974b6a3fe083eda38cb3d01d9aa2b04bdce7888544", + "e953e0638778d54ceddb78235745ed4f91f5eb05d0d59c27dccc08c1ccc7267c", + "d42f1fadf8588fba6d538352cea0867a90439ca94a16e988bf3439631625e0ba", + "e328cc982fd207aa419ab2b289c4510d2e95a7988ceccf3fb816d722e271c684", + "515232154ec5ba324c8ca107ffd9f1519caeb8112b330146d96efd78715eb075", + "3f67af96b2fbd096c015c56e986365f34f3c48d8f48aa42ac0a3a148c81f64ea", + "4d2f1dd1870a1d86dacfa2a72ea18c2c3ab689eed9480466e4a1214f3806efaf", + "2c0be286b949750cb04a57f7ed1d40226c253dd3f5d9ae994544b570e0b10334", + "7056ec198469c9a1c4e93df4c201edf0ca977e076ee601a21fce725a3df985a7", + "dbe8fe7a451786d405f01a370f47d69dfde4c14d53fa204d2545e47559fe6d83", + "705f04d243a5a3c1ceff4e030c6060b8caed632f1c691f14cca7c8c997b03401", + "2e449ead7445d65e0de5698daca28fcebaa29b16547a034470fe0678e6d52e52", + "919ee6904e41ab8a170ec89f654575c036afb9d97ab7242efeeeb06cbd3d688d", + "4ca7f777f2773826eef93e84284a27b58d85beee44b51b3167c6419830417041", + "663942bc1b38516b5388701047626de6ccfa978622709b8c382897bec882025f", + "d713c67df8ee6c3b6d3cd3ecce25cf7e68867632460d315cd1cee2a69886c07c", + "cfc2d700513b0d60d68ad6ee90b4e8dc04e7c45a92b4de0550e2943d7241fee6", + "23bd8f99e8359f0052e16c65689eae80cb20bf937ea6ca5794d36d29734a560b", + "f7c9b3e29590943b38ff1b7fa5e8cb65e73d768907396029d5fe6855c963e9d9", + "f8603e835872e1c804ef8544b8a345f7bb4ff0925b11d3da1d6648cb045fbade", + "1ce486424691a31d6b5e9fcb755119f8b1d917c65dc176c5a275f92110238adc", + "b9ee08e5abdb5c4469854d67f816519506b3ad8d8aa50d09afac35e42f6ea73d", + "199a569d05cdacfe810f183d7f114f78f4412772259c99da391aa1eb4390a9dd", + "4757a77e3611659864043267aea61c38ebab2f02773047426aecac4307ede8a4", + "d7cafd282216b04e84cf8ba7c13d08561cd49bc7c6d816b8b691deb063359145", + "c7416c8c5c173649dc37170bb7d8b29e97ed5aa810c7355cf3b52c79fd05ca6e", + "90b722413415286b4a50ab758038e52955f35ea128fabc943de4068ba687744a", + "1d48f66f2d29c82d950a117863652bf9f8cb557c85ee5a49f585670acf8d45e5", + "c22abe9884d1b5debcf86852e9cb6a012ae605140b1e8db907b8abe0d9bee523", + "b9eb6ce364c57d0123cb7cb3a0f1df5c469f28134a0438566e9bdd601b8622f2", + "6750c50fb1c0d3eef8aa684540716bd6a98fd23669008551655b1c8de9a25708", + "361837e189aba374f1e02b095d702a0cc59a3ca4d0ebbfb3c9367e68a4ecff20", + "7b12e03e4bc28aae2d137dbe65e30ebfdd1f02dc4bc3001370f39b806650923e", + "0feef38c75d9d985086da61365e620ba0996a77fb420a087ea4635be7801433c", + "9f7e5b15f0a20a830325295284b9ce5c5f7f352ef6f83fdcbdec431aac375506", + "e9f329e53c0ace3dc96c87fad621b6aa921b78cee94e620b6655849aab05f473", + "783b81ac45016a986b3a45812776415794bc38172e339fc652f704220e560a53", + "ae2fc2ec3b3e5eebcbd9e26943a71af32dd803c550651da76c77ab8eb71a2657", + "3b06f17a332ce98611838bdc2aa2f0e8c512bf98a208bdbca5c97e01d5413dd6", + "90f34ce0bc43f3c084035550a3ce9926b395dac7fe5e9b895a2376d089e8578e", + "0878d24dd431ebd8ff4d0411925080d34faf64219c1e4f21eb9a25e050ef4361", + "f4f4c3cf74765eab1f5e06cf4088dd107b7ddf56e62d8f693485913f37ac8464", + "677a663f6bc1564b27a27de11d8c6adde8b00a26cd64449e60565c3c702fad14", + "927658d1379d4b4cbf2743832d8f0ff737d329111a66aceb5470d2b4d58dda19", + "d68794c3aae12835b0b7e786c492c396e0494b785e64da876609cd4a530acfb1", + "82ceb834db6a58732c8a9ffc41d6c98eae1b84a08e9546c77a88206944c9a5e2", + "b26bd6ba8057f52163faadf64da9b7a966ea79a3a19fcf91b7331bd5f3edab36", + "8c1ea0d5c45a72e2bef3a0667fa7287ddf9afa8b15d8eb802f99c8b8b96c6838", + "50df1852f527708a9fadf478d0bb069c6de39587e0462f564c0b2c7c5776380e", + "3d55838e868095eaebc0114ebfd6b83b2f3a3e449688b8a6c98dbc6c130c7673", + "f01018b246343a26556682745de76e3f4791daf8fb2eb1804e0db9c8fb9202d4", + "3845706012cf9987a31fb12f84fd74d83c6a6f55ba248037b11609c79be59241", + "8c275b2f773ec083b990f252af74e39652ceaa13d482cf6f7a78e0f0354271a2", + "2e6a71fdaf7784924271b8df00666dead9c304df746b0bbee03cc802f49894c4", + "cc37a5bde73bab90a0a46e091d7ab0d2fbbd4adc194d303dda2bcd06fe607033", + "0f1589512695d4601df108d2ba53b22724ac291dce84b77f56077fd7a8b2ec91", + "da259d4a634924a1d9c5b5362eab01c0dda5f7d055bbb80aa2fbfb8c0cb286e3", + "b3f05b6f7d26d0d46e5fa6864d1e2b3d297b50d6ab03202aad73bab6ed214771", + "9310695e560218fd67fc3e279ee7f54298b971545225fc98b6861575e0e73a92", + "0818d7a1d0982a89c0ac99c2572b43d53b2150fd3021879da5acf42a2df599b7", + "7bc91deb0c6a73a093464cb5880906dc06c41b499ce6636686b6949d881896fd", + "f58ea17bb1f306c74b1e0fc457bc0d6e50d9e82889d8f7f458c4355ea37b78d9", + "4d3d3943d686b6573fac81579627b2bd4e82c9bbacdd0fcc3013a327e7ae1acb", + "87f9cd52330d7d665e965fa855114fb1428bda09f545fa55d6c0db962db1eb07", + "ed15782ba049fd69920ca177a07991b8551a236135a216802eb04b6ad0047eab", + "9a350b62d69df224e9ce99fd30aeda586e68219216af65f8787ff9688b9da811", + "bd931b3508b339ccf5773f6825267c89cc633cc48081c3f953bf7c63df1889d0", + "24a6ea2f7c9f8aba532a9cad74bcc5fd813244303b803be705e1c6e375e4593b", + "7fa2aa064ff867a393d499fd3fe678734d824b7fabeeafe2e751b34f1cb9b4ac", + "32d0e8008df2ec86bd881c606c948b0b9a216e37926df6fce426bc75baa9340d", + "6c7d8c9e1c67f357f510bd66a9a752e1666fbbe32e9d3be3f1e3ac7193385194", + "3ff82e184d7029e4e6446aca43a383220a360ba80afa403d520ce280beb81b2d", + "f6276f20fa01e6c6c3dbb377ee7c4eb8053db53d3265d55cdcae7aa12d6eb41a", + "e3046964710fb1b63cf2ec35ba110bc2c8e1a2d1f4eb5ee05131b2af2fd2d5d7", + "da4fae100599eb9dfb9500f28dd604665eaba000cd4b94940f3471c85c8de99d", + "0457850705a0b96353d36ad642a5a81918383c9ec8586349e26158c6a4a0b7ae", + "c92e1a01af5e072b5460b47622679b0298a978ba3cda18dc910994434b8a073c", + "89329ac82483a5d974f7b853e22923e5405ffc6d81bab3c84a8beab932d48a71", + "ea88e9ed7e4fe4ae923c7f04481a53da0ad687197558107ee3cc957895666ee9", + "abd3d2574ad462216b5e08aabe09ef9c662e60b0d1618ae1c5999838a09a5983", + "cfa1833d6bc93aff43779c869dfcf8c8a0be4b5922d19609a26a2f7405127fc0", + "814676d70f7a19a0b6a635e78e581ac2a6740d132e3e87305f798ebc6dd10353", + "1bc1bfb1626066c2377316ba20ab796716a80017f85721aaab9be5fb50dc78e3", + "0b94d3821f6c4c1fb691b61d1910ffd3555febe18ba7f30a326dee2f8d826b23", + "2517525b80437b378c1c671c4b7c87ce0a3d9de78c702efd08e2bfebd8c3156a", + "c5696ed10d3fc01103a9f2aa79a96d6e42384a5739f93a2edb5167e9331c2a5e", + "1488580ec421ed37cd1e01e1cb067a07a98716edb604bc9daac35c25b9fb1a5e", + "dccb5c741bb39cbfb540785d1610fe40e868a05617084e017b0ff413b76e0fb8", + "688055d67c2315ff096cf39a0664941e8209d434323fabf8c695efc2974e604d", + "5e19e67c4d216c91ffc7987b5b39c69f016fb7628bfed1279286c9b8d782d209", + "21ef55154770a37c1fd401d309720c5b67d069471c20c9ba1e929fd87303be2e", + "ebdf7c3063e13561e419d4daadf1116ca855a5c82aa154c8985f75a9223f98b5", + "a89b8e9799a0a20efdc61aac5c7b1f87a3e9eccab65aabd5f09d504632f79692", + "c8c81a193cc3859af01dc4babe2b1cb8346bdeae00fd5fbb137e7b89558e3d79", + "84080310788c7f2c59e6c2ee986840f0bb19aeaa2341ae14abfa5c30a03a9cb3", + "d135d67a3fb1bdfd7b8a372b127509c43a06fe798ac1f3f6ce3a2a52aef2ccc5", + "012939599a15a0b9572591240b5a37a9ed7a19ad19e5428daf7fa860cfc97c07", + "c3112134af47da13c5567aae33fb0d24019c58b1dcf5a6a70bddfe31e67803c6", + "f218c07ab165cf2eedf6998386826b75e214442cdcdb89ad8f81373285177ce3", + "792db30c597fccb843faeae6da6cdc67f0162fde98957ce1d1677c7b6e706629", + "215dc82eaf68f0837e0ed33b89febc93109dbc0aadc42a4e540c55678e42c290", + "0f232bf37eabf090eb4fa2851a9cf5651bbcd59daa3f039ebd853988680be2b5", + "3e5cb386792b79fdaea2d738696bb31484540b65378f0407b7c8cbcf4d2aec15", + "7d42108aca0b382e7295f5075f9e10e7ce0b4a5178cb828a2b54716eb0f475f7" + ], + "jsonl": { + "path": "ultrafeedback_eval.jsonl", + "sha256": "2dc018ad45f13b2a4739cb42f3a137feb6d533f7cac6ebb32affd0277612a4df" + }, + "parquet": { + "path": "ultrafeedback_eval.parquet", + "sha256": "935b45178642c319ffab5acca16fd0fd814e42b683deb9683a32195121ef7f87" + } + } + } +} diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index 6897294bc..b90f804eb 100644 --- a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -44,7 +44,7 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --load "${SAVE_DIR}/${EXP_NAME}" \ --save-interval "${SAVE_INTERVAL:-50}" \ --num-rollout "${NUM_ROLLOUT:-200}" \ - --global-batch-size "${GLOBAL_BATCH_SIZE:-8}" \ + --global-batch-size "${GLOBAL_BATCH_SIZE:-32}" \ --use-dynamic-batch-size \ --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ --tensor-model-parallel-size 1 \ diff --git a/tests/backends/megatron/test_dpo_loss.py b/tests/backends/megatron/test_dpo_loss.py index 0d38e14ce..7f7045b1f 100644 --- a/tests/backends/megatron/test_dpo_loss.py +++ b/tests/backends/megatron/test_dpo_loss.py @@ -55,12 +55,12 @@ def test_production_dpo_loss_matches_independent_reference_and_gradients(monkeyp expected.backward() torch.testing.assert_close(actual_grad, policy.grad) assert { - "dpo_logps_chosen", - "dpo_logps_rejected", - "dpo_ref_logps_chosen", - "dpo_ref_logps_rejected", - "dpo_tie_rate", - "dpo_tie_aware_accuracy", + "dpo/logps_chosen", + "dpo/logps_rejected", + "dpo/ref_logps_chosen", + "dpo/ref_logps_rejected", + "dpo/tie_rate", + "dpo/tie_aware_accuracy", }.issubset(metrics) @@ -80,9 +80,9 @@ def test_tie_metrics_are_epsilon_aware(monkeypatch): [-1.0, -2.0, -0.5, -0.75], ref_values=[-1.0, -2.0, -0.5, -0.75], ) - assert metrics["dpo_strict_accuracy"].item() == 0 - assert metrics["dpo_tie_rate"].item() == 2 - assert metrics["dpo_tie_aware_accuracy"].item() == 1 + assert metrics["dpo/strict_accuracy"].item() == 0 + assert metrics["dpo/tie_rate"].item() == 2 + assert metrics["dpo/tie_aware_accuracy"].item() == 1 def test_reference_free_partition_and_num_samples_do_not_change_pair_sum(monkeypatch): diff --git a/tests/backends/megatron/test_preference_batching.py b/tests/backends/megatron/test_preference_batching.py index dff225879..25b5c6da5 100644 --- a/tests/backends/megatron/test_preference_batching.py +++ b/tests/backends/megatron/test_preference_batching.py @@ -2,7 +2,10 @@ """Preference-row atomicity and dynamic batching tests.""" +import hashlib +import inspect from argparse import Namespace +from pathlib import Path import pytest import torch @@ -92,3 +95,58 @@ def all_reduce(tensor, *, op, **kwargs): def test_oversize_error_names_pair_cost_and_capacity(): with pytest.raises(ValueError, match=r"oversize preference pair 'pair-x'.*cost 11, capacity=10"): pack_preference_pair_indices([11], ["pair-x"], capacity=10) + + +def test_pinned_seqlen_sampler_consumes_pair_costs_and_keeps_equal_dp_groups(): + """Exercise the Docker-pinned TransferQueue sampler, not a local stand- + in.""" + transfer_queue = pytest.importorskip("transfer_queue") + sampler_type = transfer_queue.SeqlenBalancedSampler + source_path = Path(inspect.getsourcefile(sampler_type) or "") + normalized_source = source_path.read_bytes().replace(b"\r\n", b"\n") + assert hashlib.sha256(normalized_source).hexdigest() == ( + "dc6c2db50df4b9448d4845ccacef67a400517db892b5cd55de2e22f6baf6888b" + ) + + class PairPartition: + def __init__(self, pair_rows): + self.requested_indexes = None + self.metadata = { + index: {"total_lengths": len(row["chosen_tokens"]) + len(row["rejected_tokens"])} + for index, row in enumerate(pair_rows) + } + + def get_custom_meta(self, indexes): + self.requested_indexes = list(indexes) + return {index: self.metadata[index] for index in indexes} + + rows = [ + {"pair_id": 100, "chosen_tokens": list(range(60)), "rejected_tokens": list(range(40))}, + {"pair_id": 101, "chosen_tokens": list(range(50)), "rejected_tokens": list(range(40))}, + {"pair_id": 102, "chosen_tokens": list(range(6)), "rejected_tokens": list(range(4))}, + {"pair_id": 103, "chosen_tokens": [0], "rejected_tokens": [1]}, + ] + partition = PairPartition(rows) + sampler = sampler_type(n_samples_per_prompt=1, dp_size=2) + assignments = [] + for rank in range(2): + sampled, consumed = sampler.sample( + [0, 1, 2, 3], + batch_size=2, + task_name="dpo", + partition_id="train_0", + dp_rank=rank, + batch_index=0, + partition=partition, + ) + assert sampled == consumed + assert len(sampled) == 2 + assignments.append(sampled) + for index in sampled: + assert rows[index]["pair_id"] == 100 + index + assert set(rows[index]) == {"pair_id", "chosen_tokens", "rejected_tokens"} + + assert partition.requested_indexes == [0, 1, 2, 3] + assert sorted(index for rank_rows in assignments for index in rank_rows) == [0, 1, 2, 3] + rank_costs = [sum(partition.metadata[index]["total_lengths"] for index in rank_rows) for rank_rows in assignments] + assert sorted(rank_costs) == [100, 102] From 290349302fb405c38c0de7c2b4134798cfb593c5 Mon Sep 17 00:00:00 2001 From: A-Words Date: Sat, 8 Aug 2026 09:19:54 +0800 Subject: [PATCH 04/25] fix(sft): reject --ref-load for DPO objectives MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Reject --ref-load under preference objectives - Standard DPO snapshots the frozen reference from the initialized policy and rebuilds it from --hf-checkpoint on resume; --ref-load was silently ignored on that path while also rerouting the bridge mode policy-init fallback, so validate_preference_args now fails fast when it is set (RFC #208: --ref-load is not the v1 DPO reference source) - Drop the misleading --ref-load from the DPO recipe; behavior is unchanged because the bridge fallback already resolves to the same HF checkpoint --- # ♻️ Refactor ## Deduplicate the preference-mode predicate - Route data.py get_data_iterator and loss.py loss_function through is_preference_mode() instead of inline loss_type/sft_objective checks, keeping objective dispatch on a single source of truth --- # ✅ Tests ## Cover --ref-load rejection - Parametrize standard and reference-free DPO rejection cases in test_preference_runtime.py --- relax/backends/megatron/data.py | 3 ++- relax/backends/megatron/loss.py | 3 ++- relax/engine/sft/runtime.py | 5 +++++ scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 1 - tests/engine/sft/test_preference_runtime.py | 3 +++ 5 files changed, 12 insertions(+), 3 deletions(-) diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index c7aec5fd1..a57c01a27 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -15,6 +15,7 @@ from megatron.training.global_vars import get_args from torch.nn.utils.rnn import pad_sequence +from relax.engine.sft.runtime import is_preference_mode from relax.utils import device as device_utils from relax.utils import tracking_utils from relax.utils.data.data import get_minimum_num_micro_batch_size @@ -856,7 +857,7 @@ def get_data_iterator( - `data_iterators`: list of `DataIterator`, one per VPP stage (size 1 if VPP disabled) - `num_microbatches`: list[int], one per local step in the rollout (length = steps) """ - if getattr(args, "loss_type", None) == "sft" and getattr(args, "sft_objective", "causal_lm") == "dpo": + if is_preference_mode(args): return _get_preference_data_iterator(args, rollout_data, max_tokens_per_gpu) dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 1b7af9eea..02af969ce 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -9,6 +9,7 @@ from megatron.core import mpu from torch.utils.checkpoint import checkpoint +from relax.engine.sft.runtime import is_preference_mode from relax.utils.distributed_utils import distributed_masked_whiten from relax.utils.misc import load_function from relax.utils.opd.opd_utils import ( @@ -1378,7 +1379,7 @@ def loss_function( dynamic_cp_rank=batch.get("dynamic_cp_rank", None), ) num_samples = len(batch["response_lengths"]) - if getattr(args, "loss_type", None) == "sft" and getattr(args, "sft_objective", "causal_lm") == "dpo": + if is_preference_mode(args): if num_samples % 2 != 0: raise ValueError("preference micro-batch contains an odd number of branches") num_samples //= 2 diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 963ce8c40..ac4c8cdd0 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -80,6 +80,11 @@ def validate_preference_args(args: Namespace) -> None: beta = float(getattr(args, "dpo_beta", 0.1)) if not math.isfinite(beta) or beta <= 0: raise ValueError(f"--dpo-beta must be finite and positive, got {beta}") + if getattr(args, "ref_load", None) is not None: + raise ValueError( + "preference objectives do not use --ref-load: standard DPO snapshots the frozen reference " + "from the initialized policy and rebuilds it from --hf-checkpoint on resume" + ) if not getattr(args, "dpo_reference_free", False) and getattr(args, "ref_update_interval", None) is not None: raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") if not getattr(args, "dpo_reference_free", False) and not getattr(args, "enable_weights_backuper", False): diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index b90f804eb..e6ba78d77 100644 --- a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -37,7 +37,6 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --preference-chat-template-sha256 56965952fc78cd889bcd1864d70e85271861eef93385410b879c0c4c2d40564d \ --preference-require-no-generation-marker \ --hf-checkpoint "${HF_CHECKPOINT}" \ - --ref-load "${HF_CHECKPOINT}" \ --megatron-to-hf-mode bridge \ --enable-weights-backuper \ --save "${SAVE_DIR}/${EXP_NAME}" \ diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index 236a0c6fd..e88864dbb 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -37,6 +37,7 @@ def _args(**overrides) -> Namespace: "dpo_reference_free": False, "dpo_reference_repository": "Qwen/Qwen3-0.6B", "dpo_reference_revision": "fixed-revision", + "ref_load": None, "ref_update_interval": None, "enable_weights_backuper": True, "preference_max_length": 1024, @@ -65,6 +66,8 @@ def test_preference_mode_is_nested_under_sft(): ({"lora_rank": 8}, "LoRA"), ({"hidden_dropout": 0.1}, "dropout"), ({"ref_update_interval": 10}, "frozen reference"), + ({"ref_load": "/tmp/ref"}, "do not use --ref-load"), + ({"dpo_reference_free": True, "ref_load": "/tmp/ref"}, "do not use --ref-load"), ({"dpo_beta": float("nan")}, "finite and positive"), ({"preference_max_completion_length": 2048}, "must not exceed"), ({"eval_prompt_data": ["heldout", "eval.jsonl"]}, "follow-up reward-modeling PR"), From 83016e085947458b50dfb7f123825cf3eb60772c Mon Sep 17 00:00:00 2001 From: A-Words Date: Sun, 9 Aug 2026 05:05:50 +0800 Subject: [PATCH 05/25] refactor(sft): apply DPO P3 review cleanups MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # ♻️ Refactor ## Remove unreachable DPO loss fallback - Drop the dead `0 * logits.sum()` branch in dpo_loss_function: build_preference_pair_indices already raises on an empty micro-batch ## Attach stable reason codes at preference raise sites - Introduce _PreferenceRowError carrying an explicit reason_code from every normalization/split/truncation rejection; message matching in _classify_preference_error remains only as a fallback for errors raised outside the module, so reworded messages can no longer silently degrade rejections to "schema" --- # ⚡ Performance ## Merge DP pair-count collectives - Reduce _get_preference_data_iterator from three all_reduces to two by riding MIN/MAX on a single MAX all_reduce over [count, -count] ## Skip redundant same-tag model restores - _switch_model now returns early when the target tag is already active, eliminating the duplicate full-weight CPU->GPU restore after the ref-forward finally block; paths that deliberately dirty weights already clear the tag first (covered by the injected-loader-failure reference integrity test) --- # 📝 Documentation ## Note probe bitwise-determinism prerequisite - en/zh DPO guides now state that the reference probe digest assumes an identical GPU/driver/image/kernel stack on resume, and that a probe mismatch signals environment drift rather than data corruption ## Justify the checkpoint-save barrier - Comment that the post-sidecar barrier is functional (peers must not pass before rank 0 persists the identity file), and use an explicit gloo group for the rank-0 check per distributed code rules --- docs/en/guide/dpo-training.md | 2 + docs/zh/guide/dpo-training.md | 2 + relax/backends/megatron/actor.py | 11 +++- relax/backends/megatron/data.py | 23 +++++---- relax/backends/megatron/loss.py | 4 +- relax/engine/sft/dataset/preference.py | 69 +++++++++++++++++++------- 6 files changed, 79 insertions(+), 32 deletions(-) diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md index 57ed315e8..0056239f5 100644 --- a/docs/en/guide/dpo-training.md +++ b/docs/en/guide/dpo-training.md @@ -41,6 +41,8 @@ The recipe defaults to 200 optimizer steps, 32 preference pairs per global batch Standard DPO reconstructs the frozen reference from the pinned repository revision. Checkpoints include a reference-identity sidecar containing canonical parameter and fixed-probe digests. A missing or mismatched sidecar fails before the next forward pass. +The probe digest is a byte-exact SHA-256 over frozen-reference log-probabilities, so resume assumes the same GPU model, driver, image, and kernel stack as the original run. Resuming on different hardware or software fails the probe check by design — treat it as an environment mismatch, not data corruption. + Use `--dpo-reference-free` only when reference-free DPO is intended; do not combine it with the standard reference identity arguments. ## Pair-aware batching diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md index c1e536a4f..dc7239640 100644 --- a/docs/zh/guide/dpo-training.md +++ b/docs/zh/guide/dpo-training.md @@ -41,6 +41,8 @@ recipe 默认运行 200 个 optimizer step，每个 global batch 为 32 个 pref 标准 DPO 会从固定 repository revision 重建冻结 reference。checkpoint 带有 reference identity sidecar，其中保存 canonical parameter digest 和固定 probe digest；sidecar 缺失或不一致时，会在下一次 forward 前失败。 +probe digest 是对冻结 reference log-probability 的逐字节 SHA-256，因此 resume 假定 GPU 型号、驱动、镜像与内核栈与原运行完全一致。在不同硬件或软件环境上 resume 会按设计触发 probe 校验失败——这表示环境不匹配，而非数据损坏。 + 只有明确需要 reference-free DPO 时才使用 `--dpo-reference-free`，不要同时传入标准 reference identity 参数。 ## Pair-aware batching diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index 26a0949cd..d2d7136be 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -449,6 +449,12 @@ def _switch_model(self, target_tag: str) -> None: device_utils.maybe_backend_process_on_model_switch() if target_tag not in self.weights_backuper.backup_tags: raise ValueError(f"Cannot switch to unknown model tag: {target_tag}") + if self._active_model_tag == target_tag: + # Same-tag restore would be a byte-identical copy: paths that + # deliberately dirty the weights clear the tag first (see + # _rebuild_dpo_reference), so skipping avoids a redundant + # full-weight CPU->GPU copy per step after the ref forward. + return self.weights_backuper.restore(target_tag) self._active_model_tag = target_tag @@ -1825,8 +1831,11 @@ def save_model(self, rollout_id: int, force_sync: bool = False) -> None: "DPO frozen-reference checksum changed before checkpoint: " f"expected={identity.parameter_sha256}, actual={actual_sha256}" ) - if dist.get_rank() == 0: + if dist.get_rank(group=get_gloo_group()) == 0: write_reference_identity(reference_identity_path(self.args.save, rollout_id), identity) + # Functional barrier (not debugging): peers must not proceed past + # the checkpoint before rank 0's identity sidecar is durable, + # otherwise a concurrent resume could miss the file. dist.barrier(group=get_gloo_group()) if self.args.save_hf is not None and self.role == "actor": diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index a57c01a27..a04d394a8 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -792,17 +792,20 @@ def _get_preference_data_iterator( pair_costs = [int(cost) for cost in rollout_data["preference_pair_costs"]] pair_ids = [str(pair_id) for pair_id in rollout_data["preference_pair_ids"]] dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) - count_tensor = torch.tensor([len(pair_costs)], dtype=torch.int64, device=device_utils.make_current_torch_device()) - count_min = count_tensor.clone() - count_max = count_tensor.clone() - dist.all_reduce(count_tensor, op=dist.ReduceOp.SUM, group=mpu.get_data_parallel_group()) - dist.all_reduce(count_min, op=dist.ReduceOp.MIN, group=mpu.get_data_parallel_group()) - dist.all_reduce(count_max, op=dist.ReduceOp.MAX, group=mpu.get_data_parallel_group()) + dp_group = mpu.get_data_parallel_group() + device = device_utils.make_current_torch_device() + count_tensor = torch.tensor([len(pair_costs)], dtype=torch.int64, device=device) + # MIN and MAX ride a single MAX all_reduce on [count, -count]. + minmax_tensor = torch.tensor([len(pair_costs), -len(pair_costs)], dtype=torch.int64, device=device) + dist.all_reduce(count_tensor, op=dist.ReduceOp.SUM, group=dp_group) + dist.all_reduce(minmax_tensor, op=dist.ReduceOp.MAX, group=dp_group) step_global_pair_count = int(count_tensor.item()) - if int(count_min.item()) != int(count_max.item()): + global_max = int(minmax_tensor[0].item()) + global_min = -int(minmax_tensor[1].item()) + if global_min != global_max: raise ValueError( "preference objectives require equal local pair rows on every DP rank: " - f"global_min={int(count_min.item())}, global_max={int(count_max.item())}" + f"global_min={global_min}, global_max={global_max}" ) dynamic_count = rollout_data.get("dynamic_global_batch_size") if isinstance(dynamic_count, (list, tuple)): @@ -820,8 +823,8 @@ def _get_preference_data_iterator( rollout_data["dynamic_global_batch_size"] = step_global_pair_count capacity = int(max_tokens_per_gpu or args.max_tokens_per_gpu) pair_bins = pack_preference_pair_indices(pair_costs, pair_ids, capacity=capacity) - bin_count = torch.tensor([len(pair_bins)], dtype=torch.int, device=device_utils.make_current_torch_device()) - dist.all_reduce(bin_count, op=dist.ReduceOp.MAX, group=mpu.get_data_parallel_group()) + bin_count = torch.tensor([len(pair_bins)], dtype=torch.int, device=device) + dist.all_reduce(bin_count, op=dist.ReduceOp.MAX, group=dp_group) pair_bins = _split_preference_bins_to_count(pair_bins, int(bin_count.item())) if any(sum(pair_costs[index] for index in group) > capacity for group in pair_bins): raise RuntimeError("preference DP bin synchronization produced an over-capacity micro-batch") diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 02af969ce..10932bc55 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -1255,9 +1255,9 @@ def sequence_sums(token_values) -> torch.Tensor: ) chosen_rewards = args.dpo_beta * (policy_chosen - ref_chosen_for_metrics) rejected_rewards = args.dpo_beta * (policy_rejected - ref_rejected_for_metrics) + # pair_losses is never empty: build_preference_pair_indices raises on an + # empty micro-batch, so no gradient-safety fallback is needed here. loss = pair_losses.sum() - if pair_losses.numel() == 0: - loss = loss + 0 * logits.sum() reward_margin = chosen_rewards - rejected_rewards tie = reward_margin.abs() <= 1e-6 strict = reward_margin > 0 diff --git a/relax/engine/sft/dataset/preference.py b/relax/engine/sft/dataset/preference.py index 6104c2582..3f154a4f4 100644 --- a/relax/engine/sft/dataset/preference.py +++ b/relax/engine/sft/dataset/preference.py @@ -34,7 +34,20 @@ def __init__(self, reason_code: str, message: str, *, source_idx: int, pair_id: self.pair_id = pair_id +class _PreferenceRowError(ValueError): + """Internal row rejection that carries its stable reason code.""" + + def __init__(self, reason_code: str, message: str) -> None: + super().__init__(message) + self.reason_code = reason_code + + def _classify_preference_error(error: BaseException) -> str: + # Prefer the reason code attached at the raise site; message matching is + # only a fallback for errors raised outside this module (e.g. tokenizer). + reason_code = getattr(error, "reason_code", None) + if isinstance(reason_code, str) and reason_code: + return reason_code message = str(error).lower() if "post-truncation identical" in message: return "post_truncation" @@ -84,13 +97,13 @@ def pair_total_length(self) -> int: def _message_from_raw(raw: Any, *, learn: bool, field: str) -> CanonicalMessage: if not isinstance(raw, dict): - raise ValueError(f"preference {field} must be a message object") + raise _PreferenceRowError("schema", f"preference {field} must be a message object") role = raw.get("role") content = raw.get("content") if role is None or content is None: - raise ValueError(f"preference {field} message requires role and content") + raise _PreferenceRowError("schema", f"preference {field} message requires role and content") if not isinstance(content, str): - raise ValueError(f"preference {field} must be pure text") + raise _PreferenceRowError("schema", f"preference {field} must be pure text") return CanonicalMessage(role=role, content=content, learn=learn, tool_calls=raw.get("tool_calls")) @@ -107,14 +120,14 @@ def _normalize_pair_row( ) -> PreferencePair: pair_id = row.get(pair_id_key) if not isinstance(pair_id, str) or not pair_id: - raise ValueError(f"preference row requires a non-empty {pair_id_key}") + raise _PreferenceRowError("schema", f"preference row requires a non-empty {pair_id_key}") chosen_raw = row.get(chosen_key) rejected_raw = row.get(rejected_key) prompt_raw = row.get(prompt_key) if prompt_raw is None: if not isinstance(chosen_raw, list) or not isinstance(rejected_raw, list): - raise ValueError("implicit preference rows require chosen/rejected message lists") + raise _PreferenceRowError("schema", "implicit preference rows require chosen/rejected message lists") prefix_length = 0 for chosen_message, rejected_message in zip(chosen_raw, rejected_raw, strict=False): if chosen_message != rejected_message: @@ -123,24 +136,27 @@ def _normalize_pair_row( chosen_suffix = chosen_raw[prefix_length:] rejected_suffix = rejected_raw[prefix_length:] if len(chosen_suffix) != 1 or len(rejected_suffix) != 1: - raise ValueError("implicit preference rows require one assistant message after the strict common prefix") + raise _PreferenceRowError( + "prompt_mismatch", + "implicit preference rows require one assistant message after the strict common prefix", + ) prompt_raw = chosen_raw[:prefix_length] chosen_raw = chosen_suffix[0] rejected_raw = rejected_suffix[0] elif not isinstance(prompt_raw, list): - raise ValueError(f"preference {prompt_key} must be a message list") + raise _PreferenceRowError("schema", f"preference {prompt_key} must be a message list") prompt = [_message_from_raw(message, learn=False, field=prompt_key) for message in prompt_raw] chosen = _message_from_raw(chosen_raw, learn=True, field=chosen_key) rejected = _message_from_raw(rejected_raw, learn=True, field=rejected_key) if chosen.role != "assistant" or rejected.role != "assistant": - raise ValueError("preference chosen/rejected messages must have role assistant") + raise _PreferenceRowError("schema", "preference chosen/rejected messages must have role assistant") if chosen.content == rejected.content: - raise ValueError("preference chosen/rejected responses must not be identical") + raise _PreferenceRowError("identical", "preference chosen/rejected responses must not be identical") metadata = row.get(metadata_key) or {} if not isinstance(metadata, dict): - raise ValueError(f"preference {metadata_key} must be an object") + raise _PreferenceRowError("schema", f"preference {metadata_key} must be an object") metadata = dict(metadata) metadata.update({"source_dataset": source_name, "row_index": row_index, "pair_id": pair_id}) return PreferencePair(pair_id=pair_id, prompt=prompt, chosen=chosen, rejected=rejected, metadata=metadata) @@ -150,13 +166,19 @@ def _split_branch( tokens: torch.Tensor, mask: torch.Tensor, *, pair_id: str, branch: str ) -> tuple[torch.Tensor, torch.Tensor]: if tokens.ndim != 1 or mask.ndim != 1 or tokens.shape != mask.shape: - raise ValueError(f"preference pair {pair_id!r} {branch} tokens/mask must be aligned one-dimensional tensors") + raise _PreferenceRowError( + "schema", f"preference pair {pair_id!r} {branch} tokens/mask must be aligned one-dimensional tensors" + ) supervised = torch.nonzero(mask, as_tuple=False).flatten() if supervised.numel() == 0: - raise ValueError(f"preference pair {pair_id!r} {branch} completion has no supervised tokens") + raise _PreferenceRowError( + "empty_completion", f"preference pair {pair_id!r} {branch} completion has no supervised tokens" + ) first = int(supervised[0]) if not bool(mask[first:].to(dtype=torch.bool).all()): - raise ValueError(f"preference pair {pair_id!r} {branch} completion mask must be one contiguous suffix") + raise _PreferenceRowError( + "schema", f"preference pair {pair_id!r} {branch} completion mask must be one contiguous suffix" + ) return tokens[:first], tokens[first:] @@ -173,10 +195,14 @@ def _truncate_pair( chosen_completion = chosen_completion[:max_completion_length] rejected_completion = rejected_completion[:max_completion_length] if chosen_completion.numel() == 0 or rejected_completion.numel() == 0: - raise ValueError(f"preference pair {pair_id!r} has an empty completion after truncation") + raise _PreferenceRowError( + "empty_completion", f"preference pair {pair_id!r} has an empty completion after truncation" + ) prompt_budget = max_length - max(chosen_completion.numel(), rejected_completion.numel()) if prompt_budget < 0: - raise ValueError(f"preference pair {pair_id!r} completion exceeds max_length={max_length}") + raise _PreferenceRowError( + "oversize", f"preference pair {pair_id!r} completion exceeds max_length={max_length}" + ) prompt = prompt[-prompt_budget:] if prompt_budget else prompt[:0] def total() -> int: @@ -190,8 +216,9 @@ def total() -> int: elif prompt.numel() > 0: prompt = prompt[1:] else: - raise ValueError( - f"preference pair {pair_id!r} cannot fit pair capacity {pair_capacity} while retaining both completions" + raise _PreferenceRowError( + "oversize", + f"preference pair {pair_id!r} cannot fit pair capacity {pair_capacity} while retaining both completions", ) return prompt.contiguous(), chosen_completion.contiguous(), rejected_completion.contiguous() @@ -358,7 +385,9 @@ def _get_processed_pair(self, idx: int) -> ProcessedPreferencePair: rejected_tokens, rejected_mask, pair_id=pair.pair_id, branch="rejected" ) if not torch.equal(chosen_prompt, rejected_prompt): - raise ValueError(f"preference pair {pair.pair_id!r} chosen/rejected prompt tokens differ") + raise _PreferenceRowError( + "prompt_mismatch", f"preference pair {pair.pair_id!r} chosen/rejected prompt tokens differ" + ) prompt, chosen_completion, rejected_completion = _truncate_pair( chosen_prompt, chosen_completion, @@ -371,7 +400,9 @@ def _get_processed_pair(self, idx: int) -> ProcessedPreferencePair: chosen_tokens = torch.cat((prompt, chosen_completion)) rejected_tokens = torch.cat((prompt, rejected_completion)) if torch.equal(chosen_tokens, rejected_tokens) or torch.equal(chosen_completion, rejected_completion): - raise ValueError(f"preference pair {pair.pair_id!r} is post-truncation identical") + raise _PreferenceRowError( + "post_truncation", f"preference pair {pair.pair_id!r} is post-truncation identical" + ) chosen_mask = torch.cat((torch.zeros_like(prompt), torch.ones_like(chosen_completion))) rejected_mask = torch.cat((torch.zeros_like(prompt), torch.ones_like(rejected_completion))) return ProcessedPreferencePair( From 76352f2c1d667c1c3f3eb5f483ad6c64b003e15c Mon Sep 17 00:00:00 2001 From: A-Words Date: Sun, 9 Aug 2026 14:08:03 +0800 Subject: [PATCH 06/25] fix(dpo): enforce RFC validation contracts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Preserve standard DPO likelihood semantics - Reject non-unit or non-finite rollout temperatures before actor construction - Replace CUDA-to-Python condition checks with device-side asynchronous assertions - Consolidate finite-value validation on the final DPO logits ## Validate preference data preparation inputs - Validate message objects, roles, and string content on both preference branches - Classify non-object source rows as schema rejections --- # ✅ Tests ## Cover validation regressions - Test finite and non-unit temperature failures - Verify CUDA conditions avoid Python boolean conversion - Cover malformed chosen and rejected message schemas --- relax/backends/megatron/loss.py | 12 +++-- relax/engine/sft/runtime.py | 6 +++ relax/utils/training/preference_utils.py | 14 +++-- .../data/prepare_ultrafeedback_preferences.py | 28 ++++++++++ .../test_prepare_ultrafeedback_preferences.py | 53 +++++++++++++++++++ tests/engine/sft/test_preference_runtime.py | 4 ++ tests/utils/training/test_preference_utils.py | 19 +++++++ 7 files changed, 129 insertions(+), 7 deletions(-) create mode 100644 tests/data/test_prepare_ultrafeedback_preferences.py diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 10932bc55..b873050ce 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -33,7 +33,11 @@ get_reinforce_plus_plus_baseline_advantages, get_reinforce_plus_plus_returns, ) -from relax.utils.training.preference_utils import build_preference_pair_indices, dpo_pair_loss +from relax.utils.training.preference_utils import ( + build_preference_pair_indices, + dpo_pair_loss, + require_tensor_condition, +) from relax.utils.types import RolloutBatch from .cp_utils import ( @@ -1215,8 +1219,10 @@ def sequence_sums(token_values) -> torch.Tensor: "DPO branch log-probability/mask shape mismatch: " f"{tuple(branch_values.shape)} vs {tuple(branch_mask.shape)}" ) - if not bool(branch_mask.to(dtype=torch.bool).any()): - raise ValueError("DPO branch completion mask must contain at least one supervised token") + require_tensor_condition( + branch_mask.to(dtype=torch.bool).any(), + "DPO branch completion mask must contain at least one supervised token", + ) sums.append((branch_values * branch_mask).sum()) return torch.stack(sums) diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index ac4c8cdd0..ed925402a 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -80,6 +80,12 @@ def validate_preference_args(args: Namespace) -> None: beta = float(getattr(args, "dpo_beta", 0.1)) if not math.isfinite(beta) or beta <= 0: raise ValueError(f"--dpo-beta must be finite and positive, got {beta}") + likelihood_temperature = float(getattr(args, "rollout_temperature", 1.0)) + if not math.isfinite(likelihood_temperature) or likelihood_temperature != 1.0: + raise ValueError( + "preference objectives require --rollout-temperature 1.0 so sampling temperature does not scale " + "policy/reference likelihood logits" + ) if getattr(args, "ref_load", None) is not None: raise ValueError( "preference objectives do not use --ref-load: standard DPO snapshots the frozen reference " diff --git a/relax/utils/training/preference_utils.py b/relax/utils/training/preference_utils.py index 3b4c2f96f..b0df6d939 100644 --- a/relax/utils/training/preference_utils.py +++ b/relax/utils/training/preference_utils.py @@ -8,6 +8,14 @@ import torch.nn.functional as F +def require_tensor_condition(condition: torch.Tensor, message: str) -> None: + """Raise on CPU immediately and enqueue a device-side assertion on CUDA.""" + if condition.device.type == "cuda": + torch._assert_async(condition, message) + elif not bool(condition): + raise ValueError(message) + + def _validate_same_shape(name: str, *values: torch.Tensor) -> None: if not values: raise ValueError(f"{name} requires at least one tensor") @@ -15,8 +23,6 @@ def _validate_same_shape(name: str, *values: torch.Tensor) -> None: if any(value.shape != expected for value in values[1:]): shapes = [tuple(value.shape) for value in values] raise ValueError(f"{name} tensors must have identical shapes, got {shapes}") - if any(not torch.isfinite(value).all() for value in values): - raise ValueError(f"{name} tensors must contain only finite values") def build_causal_lm_labels(tokens: torch.Tensor, raw_loss_mask: torch.Tensor) -> torch.Tensor: @@ -61,8 +67,7 @@ def dpo_pair_loss( ) reference_logratio = reference_chosen - reference_rejected logits = beta * (policy_logratio - reference_logratio) - if not torch.isfinite(logits).all(): - raise ValueError("DPO logits must contain only finite values") + require_tensor_condition(torch.isfinite(logits).all(), "DPO logits must contain only finite values") return -F.logsigmoid(logits) @@ -147,4 +152,5 @@ def pack_preference_pair_indices( "build_causal_lm_labels", "dpo_pair_loss", "pack_preference_pair_indices", + "require_tensor_condition", ] diff --git a/scripts/data/prepare_ultrafeedback_preferences.py b/scripts/data/prepare_ultrafeedback_preferences.py index de8d5ad38..12c13f304 100644 --- a/scripts/data/prepare_ultrafeedback_preferences.py +++ b/scripts/data/prepare_ultrafeedback_preferences.py @@ -9,6 +9,8 @@ from pathlib import Path from typing import Any +from relax.engine.sft.dataset.sample import VALID_ROLES + DATASET_ID = "HuggingFaceH4/ultrafeedback_binarized" DATASET_REVISION = "3949bf5f8c17c394422ccfab0c31ea9c20bdeb85" @@ -48,6 +50,22 @@ def _validate_row(row: dict[str, Any], *, split: str, index: int) -> str: rejected = row.get("rejected") if not isinstance(chosen, list) or not isinstance(rejected, list) or not chosen or not rejected: raise ValueError(f"{split}[{index}] {prompt_id} has invalid chosen/rejected messages") + for branch_name, messages in (("chosen", chosen), ("rejected", rejected)): + for message_index, message in enumerate(messages): + if not isinstance(message, dict): + raise ValueError( + f"{split}[{index}] {prompt_id} {branch_name}[{message_index}] must be a message object" + ) + role = message.get("role") + content = message.get("content") + if role not in VALID_ROLES: + raise ValueError( + f"{split}[{index}] {prompt_id} {branch_name}[{message_index}] has invalid role {role!r}" + ) + if not isinstance(content, str): + raise ValueError( + f"{split}[{index}] {prompt_id} {branch_name}[{message_index}] content must be a string" + ) if chosen == rejected: raise ValueError(f"{split}[{index}] {prompt_id} has identical chosen/rejected branches") if chosen[-1].get("role") != "assistant" or rejected[-1].get("role") != "assistant": @@ -62,6 +80,16 @@ def _select(dataset, *, split: str, count: int) -> tuple[list[dict[str, Any]], l candidates: list[tuple[str, str, dict[str, Any]]] = [] rejected: list[dict[str, Any]] = [] for index, row in enumerate(dataset): + if not isinstance(row, dict): + rejected.append( + { + "prompt_id": None, + "source_index": index, + "reason_code": "schema", + "reason": f"{split}[{index}] must be an object", + } + ) + continue prompt_id = row.get("prompt_id") if not isinstance(prompt_id, str) or not prompt_id: raise ValueError(f"{split}[{index}] has no non-empty prompt_id") diff --git a/tests/data/test_prepare_ultrafeedback_preferences.py b/tests/data/test_prepare_ultrafeedback_preferences.py new file mode 100644 index 000000000..93ae94e40 --- /dev/null +++ b/tests/data/test_prepare_ultrafeedback_preferences.py @@ -0,0 +1,53 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Schema validation for the deterministic UltraFeedback preparation script.""" + +import pytest + +from scripts.data.prepare_ultrafeedback_preferences import _select, _validate_row + + +def _row() -> dict: + return { + "prompt_id": "pair-1", + "chosen": [ + {"role": "user", "content": "question"}, + {"role": "assistant", "content": "good"}, + ], + "rejected": [ + {"role": "user", "content": "question"}, + {"role": "assistant", "content": "bad"}, + ], + } + + +@pytest.mark.parametrize( + ("replacement", "match"), + [ + ("not-a-message", "message object"), + ({"content": "question"}, "invalid role"), + ({"role": "invalid", "content": "question"}, "invalid role"), + ({"role": "user", "content": 123}, "content must be a string"), + ], +) +@pytest.mark.parametrize("branch", ["chosen", "rejected"]) +def test_validate_row_rejects_invalid_message_schema(replacement, match: str, branch: str): + row = _row() + row[branch][0] = replacement + + with pytest.raises(ValueError, match=match): + _validate_row(row, split="train_prefs", index=0) + + +def test_select_classifies_non_object_rows_as_schema_rejections(): + selected, rejected = _select(["not-an-object", _row()], split="train_prefs", count=1) + + assert selected[0]["prompt_id"] == "pair-1" + assert rejected == [ + { + "prompt_id": None, + "source_index": 0, + "reason_code": "schema", + "reason": "train_prefs[0] must be an object", + } + ] diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index e88864dbb..8dbd08887 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -34,6 +34,7 @@ def _args(**overrides) -> Namespace: "eval_prompt_data": None, "eval_size": None, "dpo_beta": 0.1, + "rollout_temperature": 1.0, "dpo_reference_free": False, "dpo_reference_repository": "Qwen/Qwen3-0.6B", "dpo_reference_revision": "fixed-revision", @@ -69,6 +70,9 @@ def test_preference_mode_is_nested_under_sft(): ({"ref_load": "/tmp/ref"}, "do not use --ref-load"), ({"dpo_reference_free": True, "ref_load": "/tmp/ref"}, "do not use --ref-load"), ({"dpo_beta": float("nan")}, "finite and positive"), + ({"rollout_temperature": 0.8}, "rollout-temperature 1.0"), + ({"rollout_temperature": float("nan")}, "rollout-temperature 1.0"), + ({"rollout_temperature": float("inf")}, "rollout-temperature 1.0"), ({"preference_max_completion_length": 2048}, "must not exceed"), ({"eval_prompt_data": ["heldout", "eval.jsonl"]}, "follow-up reward-modeling PR"), ], diff --git a/tests/utils/training/test_preference_utils.py b/tests/utils/training/test_preference_utils.py index 4900c04b4..f1cf2d4a1 100644 --- a/tests/utils/training/test_preference_utils.py +++ b/tests/utils/training/test_preference_utils.py @@ -2,6 +2,8 @@ """Pure numerical and batching tests for offline preference training.""" +from types import SimpleNamespace + import pytest import torch import torch.nn.functional as F @@ -10,9 +12,26 @@ build_causal_lm_labels, dpo_pair_loss, pack_preference_pair_indices, + require_tensor_condition, ) +def test_tensor_condition_uses_async_assert_without_python_bool_on_cuda(monkeypatch): + class _CudaCondition: + device = SimpleNamespace(type="cuda") + + def __bool__(self): + raise AssertionError("CUDA conditions must not be converted to Python bool") + + calls = [] + monkeypatch.setattr(torch, "_assert_async", lambda condition, message: calls.append((condition, message))) + condition = _CudaCondition() + + require_tensor_condition(condition, "finite") + + assert calls == [(condition, "finite")] + + def test_build_causal_lm_labels_uses_next_token_mask(): tokens = torch.tensor([10, 11, 12, 13, 14]) raw_mask = torch.tensor([0, 0, 1, 1, 1]) From 5b26ecbf2a38a1dee1e2ebfbfb1adbe7436144bc Mon Sep 17 00:00:00 2001 From: A-Words Date: Sun, 9 Aug 2026 23:51:51 +0800 Subject: [PATCH 07/25] fix(dpo): pin frozen reference snapshot MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Pin standard DPO frozen reference provenance - Resolve the reference from the declared repository and revision in the configured HF checkpoint directory - Require Hugging Face local metadata to verify the pinned snapshot without downloading during actor startup - Rebuild the frozen reference from that verified directory for both fresh starts and resumes - Fail clearly when the configured checkpoint is unavailable, unverified, or resolves elsewhere --- # 📝 Documentation ## Document pinned local model preparation - Show the fixed-revision hf download command used by the public DPO recipe --- # ✅ Tests ## Cover local reference resolution - Verify repository, revision, local directory, and local-only cache resolution - Verify missing metadata and mismatched resolved directories fail before model loading --- docs/en/guide/dpo-training.md | 5 +- docs/zh/guide/dpo-training.md | 5 +- relax/backends/megatron/actor.py | 11 ++-- .../backends/megatron/reference_integrity.py | 37 +++++++++++++ relax/engine/sft/runtime.py | 2 +- .../megatron/test_dpo_reference_integrity.py | 52 +++++++++++++++++++ 6 files changed, 104 insertions(+), 8 deletions(-) diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md index 0056239f5..ae8a02a78 100644 --- a/docs/en/guide/dpo-training.md +++ b/docs/en/guide/dpo-training.md @@ -31,15 +31,18 @@ Download the pinned Qwen checkpoint, then set the model, data, and output locati ```bash export MODEL_DIR=/models +export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +export HF_CHECKPOINT="${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}" export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet export SAVE_DIR=/checkpoints/task31-dpo +hf download Qwen/Qwen3-0.6B --revision "${MODEL_REVISION}" --local-dir "${HF_CHECKPOINT}" bash scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh ``` The recipe defaults to 200 optimizer steps, 32 preference pairs per global batch, `beta=0.1`, and a 1,024-token branch limit. `GLOBAL_BATCH_SIZE`, `NUM_ROLLOUT`, `MAX_TOKENS_PER_GPU`, and `SAVE_INTERVAL` can be overridden explicitly. -Standard DPO reconstructs the frozen reference from the pinned repository revision. Checkpoints include a reference-identity sidecar containing canonical parameter and fixed-probe digests. A missing or mismatched sidecar fails before the next forward pass. +Standard DPO verifies the pinned repository revision against the local `HF_CHECKPOINT` directory, then reconstructs the frozen reference from that directory. Checkpoints include a reference-identity sidecar containing canonical parameter and fixed-probe digests. A missing or mismatched sidecar fails before the next forward pass. The probe digest is a byte-exact SHA-256 over frozen-reference log-probabilities, so resume assumes the same GPU model, driver, image, and kernel stack as the original run. Resuming on different hardware or software fails the probe check by design — treat it as an environment mismatch, not data corruption. diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md index dc7239640..eab25f722 100644 --- a/docs/zh/guide/dpo-training.md +++ b/docs/zh/guide/dpo-training.md @@ -31,15 +31,18 @@ chosen/rejected 必须共享完全相同的 prompt，并包含不同且非空的 ```bash export MODEL_DIR=/models +export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +export HF_CHECKPOINT="${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}" export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet export SAVE_DIR=/checkpoints/task31-dpo +hf download Qwen/Qwen3-0.6B --revision "${MODEL_REVISION}" --local-dir "${HF_CHECKPOINT}" bash scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh ``` recipe 默认运行 200 个 optimizer step，每个 global batch 为 32 个 preference pair，`beta=0.1`，单分支最大 1,024 token。可以显式覆盖 `GLOBAL_BATCH_SIZE`、`NUM_ROLLOUT`、`MAX_TOKENS_PER_GPU` 和 `SAVE_INTERVAL`。 -标准 DPO 会从固定 repository revision 重建冻结 reference。checkpoint 带有 reference identity sidecar，其中保存 canonical parameter digest 和固定 probe digest；sidecar 缺失或不一致时，会在下一次 forward 前失败。 +标准 DPO 会先在本地 `HF_CHECKPOINT` 目录中校验固定的 repository revision，再从该目录重建冻结 reference。checkpoint 带有 reference identity sidecar，其中保存 canonical parameter digest 和固定 probe digest；sidecar 缺失或不一致时，会在下一次 forward 前失败。 probe digest 是对冻结 reference log-probability 的逐字节 SHA-256，因此 resume 假定 GPU 型号、驱动、镜像与内核栈与原运行完全一致。在不同硬件或软件环境上 resume 会按设计触发 probe 校验失败——这表示环境不匹配，而非数据损坏。 diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index d2d7136be..b119649c3 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -103,6 +103,7 @@ read_reference_identity, reference_identity_path, reference_probe_sha256, + resolve_dpo_reference_checkpoint, write_reference_identity, ) from .weight_update.common import named_params_and_buffers @@ -285,13 +286,13 @@ def _init( if with_ref: if is_preference_mode(args) and args.sft_objective == "dpo": - if not resumed_from_megatron: - self.weights_backuper.backup("ref") - self._dpo_reference_identity = self._build_dpo_reference_identity() - else: + reference_checkpoint = resolve_dpo_reference_checkpoint( + args.dpo_reference_repository, args.dpo_reference_revision, args.hf_checkpoint + ) + if resumed_from_megatron: identity_path = reference_identity_path(args.load, loaded_rollout_id) self._expected_dpo_reference_identity = read_reference_identity(identity_path) - self._rebuild_dpo_reference(args.hf_checkpoint) + self._rebuild_dpo_reference(reference_checkpoint) else: self.load_other_checkpoint("ref", args.ref_load) diff --git a/relax/backends/megatron/reference_integrity.py b/relax/backends/megatron/reference_integrity.py index 93e77c760..c2f09ac93 100644 --- a/relax/backends/megatron/reference_integrity.py +++ b/relax/backends/megatron/reference_integrity.py @@ -17,6 +17,42 @@ REFERENCE_LOADER_MODE = "hf_bridge_model_only_v1" +def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_checkpoint: str) -> str: + """Resolve a pinned DPO reference in the configured local model + directory.""" + try: + from huggingface_hub import snapshot_download + except ImportError as exc: + raise RuntimeError("standard DPO requires huggingface_hub to resolve its frozen reference") from exc + + try: + configured_checkpoint = Path(local_checkpoint).resolve(strict=True) + checkpoint = Path( + snapshot_download( + repo_id=repository, + revision=revision, + local_dir=str(configured_checkpoint), + local_files_only=True, + ) + ).resolve(strict=True) + except OSError as exc: + raise RuntimeError( + "standard DPO requires its pinned reference in --hf-checkpoint; prepare it with " + f"`hf download {repository} --revision {revision} --local-dir {local_checkpoint}`" + ) from exc + if checkpoint != configured_checkpoint: + raise RuntimeError( + "DPO reference resolution returned a directory different from --hf-checkpoint: " + f"configured={configured_checkpoint}, resolved={checkpoint}" + ) + if not (checkpoint / "config.json").is_file(): + raise RuntimeError( + "resolved DPO reference snapshot is missing config.json: " + f"repository={repository!r}, revision={revision!r}, path={checkpoint}" + ) + return str(checkpoint) + + @dataclass(frozen=True) class DPOReferenceIdentity: """Identity persisted beside every standard-DPO checkpoint.""" @@ -171,5 +207,6 @@ def read_reference_identity(path: Path) -> DPOReferenceIdentity: "read_reference_identity", "reference_identity_path", "reference_probe_sha256", + "resolve_dpo_reference_checkpoint", "write_reference_identity", ] diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index ed925402a..35fe18c00 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -89,7 +89,7 @@ def validate_preference_args(args: Namespace) -> None: if getattr(args, "ref_load", None) is not None: raise ValueError( "preference objectives do not use --ref-load: standard DPO snapshots the frozen reference " - "from the initialized policy and rebuilds it from --hf-checkpoint on resume" + "from the pinned --dpo-reference-repository/--dpo-reference-revision snapshot" ) if not getattr(args, "dpo_reference_free", False) and getattr(args, "ref_update_interval", None) is not None: raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py index bb76a10fc..be1fc70f8 100644 --- a/tests/backends/megatron/test_dpo_reference_integrity.py +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -3,6 +3,8 @@ """Frozen-reference checksum, probe, optimizer and sidecar tests.""" import json +import sys +import types from argparse import Namespace import pytest @@ -15,6 +17,7 @@ canonical_tensor_sha256, read_reference_identity, reference_probe_sha256, + resolve_dpo_reference_checkpoint, write_reference_identity, ) @@ -81,6 +84,55 @@ def test_reference_identity_sidecar_is_required_and_rejects_schema_damage(tmp_pa read_reference_identity(path) +def test_resolve_dpo_reference_checkpoint_uses_the_pinned_configured_local_snapshot(monkeypatch, tmp_path): + snapshot = tmp_path / "Qwen3-0.6B-fixed-revision" + snapshot.mkdir() + (snapshot / "config.json").write_text("{}", encoding="utf-8") + observed = {} + + def snapshot_download(**kwargs): + observed.update(kwargs) + return str(snapshot) + + monkeypatch.setitem(sys.modules, "huggingface_hub", types.SimpleNamespace(snapshot_download=snapshot_download)) + assert resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(snapshot)) == str(snapshot.resolve()) + assert observed == { + "repo_id": "org/model", + "revision": "fixed-revision", + "local_dir": str(snapshot.resolve()), + "local_files_only": True, + } + + +def test_resolve_dpo_reference_checkpoint_rejects_missing_local_snapshot(monkeypatch, tmp_path): + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + + def snapshot_download(**_kwargs): + raise OSError("not cached") + + monkeypatch.setitem(sys.modules, "huggingface_hub", types.SimpleNamespace(snapshot_download=snapshot_download)) + with pytest.raises(RuntimeError, match="hf download org/model --revision fixed-revision"): + resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(checkpoint)) + + +def test_resolve_dpo_reference_checkpoint_rejects_different_resolved_directory(monkeypatch, tmp_path): + checkpoint = tmp_path / "checkpoint" + other = tmp_path / "other" + checkpoint.mkdir() + other.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + (other / "config.json").write_text("{}", encoding="utf-8") + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(other)), + ) + with pytest.raises(RuntimeError, match="different from --hf-checkpoint"): + resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(checkpoint)) + + def test_resume_probe_materializes_manifest_lists_as_tensors(monkeypatch): try: from relax.backends.megatron import actor as actor_module From cac9492b956a48c65ebc0e15ebc02e37a56c7c71 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 00:25:32 +0800 Subject: [PATCH 08/25] fix(dpo): verify local reference metadata MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Require pinned local snapshot metadata - Require an immutable 40-character commit SHA for standard DPO references - Verify Hugging Face local-dir tree metadata before accepting the configured checkpoint - Reject copied or incomplete local snapshots that lack pinned provenance metadata --- # ✅ Tests ## Cover metadata validation - Exercise the pinned tree lookup and missing-metadata rejection paths - Document the full commit-SHA requirement for the DPO recipe --- docs/en/guide/dpo-training.md | 2 +- docs/zh/guide/dpo-training.md | 2 +- .../backends/megatron/reference_integrity.py | 19 ++++- .../megatron/test_dpo_reference_integrity.py | 71 ++++++++++++++++--- 4 files changed, 82 insertions(+), 12 deletions(-) diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md index ae8a02a78..d3dacdf01 100644 --- a/docs/en/guide/dpo-training.md +++ b/docs/en/guide/dpo-training.md @@ -31,7 +31,7 @@ Download the pinned Qwen checkpoint, then set the model, data, and output locati ```bash export MODEL_DIR=/models -export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca # full 40-character commit SHA export HF_CHECKPOINT="${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}" export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet export SAVE_DIR=/checkpoints/task31-dpo diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md index eab25f722..7608d97ad 100644 --- a/docs/zh/guide/dpo-training.md +++ b/docs/zh/guide/dpo-training.md @@ -31,7 +31,7 @@ chosen/rejected 必须共享完全相同的 prompt，并包含不同且非空的 ```bash export MODEL_DIR=/models -export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +export MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca # 完整的 40 位 commit SHA export HF_CHECKPOINT="${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}" export PROMPT_DATA=/data/task31-ultrafeedback/ultrafeedback_train.parquet export SAVE_DIR=/checkpoints/task31-dpo diff --git a/relax/backends/megatron/reference_integrity.py b/relax/backends/megatron/reference_integrity.py index c2f09ac93..f4d2a6d7e 100644 --- a/relax/backends/megatron/reference_integrity.py +++ b/relax/backends/megatron/reference_integrity.py @@ -5,6 +5,7 @@ import hashlib import json import os +import re from collections.abc import Iterable, Mapping, Sequence from dataclasses import asdict, dataclass from pathlib import Path @@ -15,16 +16,21 @@ REFERENCE_IDENTITY_FILENAME = "relax_dpo_reference.json" REFERENCE_LOADER_MODE = "hf_bridge_model_only_v1" +_GIT_COMMIT_SHA256_RE = re.compile(r"^[0-9a-f]{40}$") def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_checkpoint: str) -> str: """Resolve a pinned DPO reference in the configured local model directory.""" try: - from huggingface_hub import snapshot_download + from huggingface_hub import get_cached_repo_tree, snapshot_download + from huggingface_hub.errors import CachedRepoTreeNotFoundError except ImportError as exc: raise RuntimeError("standard DPO requires huggingface_hub to resolve its frozen reference") from exc + if _GIT_COMMIT_SHA256_RE.fullmatch(revision) is None: + raise ValueError("standard DPO requires --dpo-reference-revision to be a full 40-character commit SHA") + try: configured_checkpoint = Path(local_checkpoint).resolve(strict=True) checkpoint = Path( @@ -50,6 +56,17 @@ def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_check "resolved DPO reference snapshot is missing config.json: " f"repository={repository!r}, revision={revision!r}, path={checkpoint}" ) + try: + get_cached_repo_tree( + repo_id=repository, + revision=revision, + local_dir=str(configured_checkpoint), + ) + except CachedRepoTreeNotFoundError as exc: + raise RuntimeError( + "DPO reference is missing pinned Hugging Face local-dir metadata; re-download it with " + f"`hf download {repository} --revision {revision} --local-dir {local_checkpoint}`" + ) from exc return str(checkpoint) diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py index be1fc70f8..23807c698 100644 --- a/tests/backends/megatron/test_dpo_reference_integrity.py +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -85,7 +85,8 @@ def test_reference_identity_sidecar_is_required_and_rejects_schema_damage(tmp_pa def test_resolve_dpo_reference_checkpoint_uses_the_pinned_configured_local_snapshot(monkeypatch, tmp_path): - snapshot = tmp_path / "Qwen3-0.6B-fixed-revision" + revision = "a" * 40 + snapshot = tmp_path / f"Qwen3-0.6B-{revision}" snapshot.mkdir() (snapshot / "config.json").write_text("{}", encoding="utf-8") observed = {} @@ -94,13 +95,29 @@ def snapshot_download(**kwargs): observed.update(kwargs) return str(snapshot) - monkeypatch.setitem(sys.modules, "huggingface_hub", types.SimpleNamespace(snapshot_download=snapshot_download)) - assert resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(snapshot)) == str(snapshot.resolve()) + def get_cached_repo_tree(**kwargs): + observed["tree"] = kwargs + return [] + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=snapshot_download, get_cached_repo_tree=get_cached_repo_tree), + ) + monkeypatch.setitem( + sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) + ) + assert resolve_dpo_reference_checkpoint("org/model", revision, str(snapshot)) == str(snapshot.resolve()) assert observed == { "repo_id": "org/model", - "revision": "fixed-revision", + "revision": revision, "local_dir": str(snapshot.resolve()), "local_files_only": True, + "tree": { + "repo_id": "org/model", + "revision": revision, + "local_dir": str(snapshot.resolve()), + }, } @@ -111,9 +128,16 @@ def test_resolve_dpo_reference_checkpoint_rejects_missing_local_snapshot(monkeyp def snapshot_download(**_kwargs): raise OSError("not cached") - monkeypatch.setitem(sys.modules, "huggingface_hub", types.SimpleNamespace(snapshot_download=snapshot_download)) - with pytest.raises(RuntimeError, match="hf download org/model --revision fixed-revision"): - resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(checkpoint)) + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=snapshot_download, get_cached_repo_tree=lambda **_kwargs: []), + ) + monkeypatch.setitem( + sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) + ) + with pytest.raises(RuntimeError, match="hf download org/model --revision"): + resolve_dpo_reference_checkpoint("org/model", "a" * 40, str(checkpoint)) def test_resolve_dpo_reference_checkpoint_rejects_different_resolved_directory(monkeypatch, tmp_path): @@ -127,10 +151,39 @@ def test_resolve_dpo_reference_checkpoint_rejects_different_resolved_directory(m monkeypatch.setitem( sys.modules, "huggingface_hub", - types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(other)), + types.SimpleNamespace( + snapshot_download=lambda **_kwargs: str(other), get_cached_repo_tree=lambda **_kwargs: [] + ), + ) + monkeypatch.setitem( + sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) ) with pytest.raises(RuntimeError, match="different from --hf-checkpoint"): - resolve_dpo_reference_checkpoint("org/model", "fixed-revision", str(checkpoint)) + resolve_dpo_reference_checkpoint("org/model", "a" * 40, str(checkpoint)) + + +def test_resolve_dpo_reference_checkpoint_rejects_missing_pinned_local_metadata(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + missing_metadata = type("CachedRepoTreeNotFoundError", (Exception,), {}) + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace( + snapshot_download=lambda **_kwargs: str(checkpoint), + get_cached_repo_tree=lambda **_kwargs: (_ for _ in ()).throw(missing_metadata()), + ), + ) + monkeypatch.setitem( + sys.modules, + "huggingface_hub.errors", + types.SimpleNamespace(CachedRepoTreeNotFoundError=missing_metadata), + ) + with pytest.raises(RuntimeError, match="missing pinned Hugging Face local-dir metadata"): + resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) def test_resume_probe_materializes_manifest_lists_as_tensors(monkeypatch): From 1b9d595cb10acd4b196c3b4c2eaa2c7f2c10761d Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 00:44:19 +0800 Subject: [PATCH 09/25] fix(dpo): verify reference file digests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Validate pinned Hugging Face local snapshots - Parse the per-file metadata format used by pinned huggingface_hub 1.7.2 - Require every reference file to match the configured commit revision - Verify regular Git files with Git blob SHA-1 and LFS files with SHA-256 - Stream large-file hashing to keep reference validation memory bounded --- # ✅ Tests ## Cover reference provenance and integrity - Exercise Git and LFS ETag validation - Reject missing or mismatched local metadata - Reject replaced weights even when their original mtime is restored --- .../backends/megatron/reference_integrity.py | 59 ++++++++++--- .../megatron/test_dpo_reference_integrity.py | 88 ++++++++++++------- 2 files changed, 106 insertions(+), 41 deletions(-) diff --git a/relax/backends/megatron/reference_integrity.py b/relax/backends/megatron/reference_integrity.py index f4d2a6d7e..066bea64c 100644 --- a/relax/backends/megatron/reference_integrity.py +++ b/relax/backends/megatron/reference_integrity.py @@ -4,6 +4,7 @@ import hashlib import json +import math import os import re from collections.abc import Iterable, Mapping, Sequence @@ -17,14 +18,57 @@ REFERENCE_IDENTITY_FILENAME = "relax_dpo_reference.json" REFERENCE_LOADER_MODE = "hf_bridge_model_only_v1" _GIT_COMMIT_SHA256_RE = re.compile(r"^[0-9a-f]{40}$") +_HF_ETAG_RE = re.compile(r"^(?:[0-9a-f]{40}|[0-9a-f]{64})$") + + +def _file_matches_hf_etag(path: Path, etag: str) -> bool: + digest = hashlib.sha256() if len(etag) == 64 else hashlib.sha1() + with path.open("rb") as file: + if len(etag) == 40: + size = os.fstat(file.fileno()).st_size + digest.update(f"blob {size}\0".encode()) + while chunk := file.read(1024 * 1024): + digest.update(chunk) + return digest.hexdigest() == etag + + +def _validate_local_download_metadata(checkpoint: Path, revision: str) -> None: + metadata_root = checkpoint / ".cache" / "huggingface" / "download" + snapshot_files = [ + path for path in checkpoint.rglob("*") if path.is_file() and checkpoint / ".cache" not in path.parents + ] + for path in snapshot_files: + relative_path = path.relative_to(checkpoint) + metadata_path = metadata_root.joinpath(*relative_path.parts).with_name(f"{relative_path.name}.metadata") + try: + lines = metadata_path.read_text(encoding="utf-8").splitlines() + metadata_revision, etag, timestamp_text = lines + timestamp = float(timestamp_text) + except (OSError, ValueError) as exc: + raise RuntimeError( + f"DPO reference file is missing valid Hugging Face local-dir metadata: {relative_path.as_posix()!r}" + ) from exc + if ( + metadata_revision != revision + or _HF_ETAG_RE.fullmatch(etag) is None + or not math.isfinite(timestamp) + or path.stat().st_mtime - 1 > timestamp + ): + raise RuntimeError( + "DPO reference file metadata does not match the pinned revision or file contents: " + f"{relative_path.as_posix()!r}" + ) + if not _file_matches_hf_etag(path, etag): + raise RuntimeError( + f"DPO reference file contents do not match its Hugging Face ETag: {relative_path.as_posix()!r}" + ) def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_checkpoint: str) -> str: """Resolve a pinned DPO reference in the configured local model directory.""" try: - from huggingface_hub import get_cached_repo_tree, snapshot_download - from huggingface_hub.errors import CachedRepoTreeNotFoundError + from huggingface_hub import snapshot_download except ImportError as exc: raise RuntimeError("standard DPO requires huggingface_hub to resolve its frozen reference") from exc @@ -57,15 +101,10 @@ def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_check f"repository={repository!r}, revision={revision!r}, path={checkpoint}" ) try: - get_cached_repo_tree( - repo_id=repository, - revision=revision, - local_dir=str(configured_checkpoint), - ) - except CachedRepoTreeNotFoundError as exc: + _validate_local_download_metadata(checkpoint, revision) + except RuntimeError as exc: raise RuntimeError( - "DPO reference is missing pinned Hugging Face local-dir metadata; re-download it with " - f"`hf download {repository} --revision {revision} --local-dir {local_checkpoint}`" + f"{exc}; re-download with `hf download {repository} --revision {revision} --local-dir {local_checkpoint}`" ) from exc return str(checkpoint) diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py index 23807c698..24541ac1a 100644 --- a/tests/backends/megatron/test_dpo_reference_integrity.py +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -2,7 +2,9 @@ """Frozen-reference checksum, probe, optimizer and sidecar tests.""" +import hashlib import json +import os import sys import types from argparse import Namespace @@ -84,28 +86,36 @@ def test_reference_identity_sidecar_is_required_and_rejects_schema_damage(tmp_pa read_reference_identity(path) +def _write_local_download_metadata(checkpoint, filename, revision): + source = checkpoint / filename + metadata = checkpoint / ".cache" / "huggingface" / "download" / f"{filename}.metadata" + metadata.parent.mkdir(parents=True, exist_ok=True) + content = source.read_bytes() + if source.suffix == ".safetensors": + etag = hashlib.sha256(content).hexdigest() + else: + etag = hashlib.sha1(f"blob {len(content)}\0".encode() + content).hexdigest() + metadata.write_text(f"{revision}\n{etag}\n{source.stat().st_mtime}\n", encoding="utf-8") + + def test_resolve_dpo_reference_checkpoint_uses_the_pinned_configured_local_snapshot(monkeypatch, tmp_path): revision = "a" * 40 snapshot = tmp_path / f"Qwen3-0.6B-{revision}" snapshot.mkdir() (snapshot / "config.json").write_text("{}", encoding="utf-8") + (snapshot / "model.safetensors").write_bytes(b"weights") + _write_local_download_metadata(snapshot, "config.json", revision) + _write_local_download_metadata(snapshot, "model.safetensors", revision) observed = {} def snapshot_download(**kwargs): observed.update(kwargs) return str(snapshot) - def get_cached_repo_tree(**kwargs): - observed["tree"] = kwargs - return [] - monkeypatch.setitem( sys.modules, "huggingface_hub", - types.SimpleNamespace(snapshot_download=snapshot_download, get_cached_repo_tree=get_cached_repo_tree), - ) - monkeypatch.setitem( - sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) + types.SimpleNamespace(snapshot_download=snapshot_download), ) assert resolve_dpo_reference_checkpoint("org/model", revision, str(snapshot)) == str(snapshot.resolve()) assert observed == { @@ -113,11 +123,6 @@ def get_cached_repo_tree(**kwargs): "revision": revision, "local_dir": str(snapshot.resolve()), "local_files_only": True, - "tree": { - "repo_id": "org/model", - "revision": revision, - "local_dir": str(snapshot.resolve()), - }, } @@ -131,10 +136,7 @@ def snapshot_download(**_kwargs): monkeypatch.setitem( sys.modules, "huggingface_hub", - types.SimpleNamespace(snapshot_download=snapshot_download, get_cached_repo_tree=lambda **_kwargs: []), - ) - monkeypatch.setitem( - sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) + types.SimpleNamespace(snapshot_download=snapshot_download), ) with pytest.raises(RuntimeError, match="hf download org/model --revision"): resolve_dpo_reference_checkpoint("org/model", "a" * 40, str(checkpoint)) @@ -151,12 +153,7 @@ def test_resolve_dpo_reference_checkpoint_rejects_different_resolved_directory(m monkeypatch.setitem( sys.modules, "huggingface_hub", - types.SimpleNamespace( - snapshot_download=lambda **_kwargs: str(other), get_cached_repo_tree=lambda **_kwargs: [] - ), - ) - monkeypatch.setitem( - sys.modules, "huggingface_hub.errors", types.SimpleNamespace(CachedRepoTreeNotFoundError=RuntimeError) + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(other)), ) with pytest.raises(RuntimeError, match="different from --hf-checkpoint"): resolve_dpo_reference_checkpoint("org/model", "a" * 40, str(checkpoint)) @@ -167,22 +164,51 @@ def test_resolve_dpo_reference_checkpoint_rejects_missing_pinned_local_metadata( checkpoint = tmp_path / "checkpoint" checkpoint.mkdir() (checkpoint / "config.json").write_text("{}", encoding="utf-8") - missing_metadata = type("CachedRepoTreeNotFoundError", (Exception,), {}) + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), + ) + with pytest.raises(RuntimeError, match="missing valid Hugging Face local-dir metadata"): + resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) + + +def test_resolve_dpo_reference_checkpoint_rejects_mismatched_file_metadata(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + _write_local_download_metadata(checkpoint, "config.json", "c" * 40) monkeypatch.setitem( sys.modules, "huggingface_hub", - types.SimpleNamespace( - snapshot_download=lambda **_kwargs: str(checkpoint), - get_cached_repo_tree=lambda **_kwargs: (_ for _ in ()).throw(missing_metadata()), - ), + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), ) + with pytest.raises(RuntimeError, match="metadata does not match the pinned revision"): + resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) + + +def test_resolve_dpo_reference_checkpoint_rejects_replaced_file_with_restored_mtime(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + config = checkpoint / "config.json" + config.write_text("{}", encoding="utf-8") + _write_local_download_metadata(checkpoint, "config.json", revision) + weights = checkpoint / "model.safetensors" + weights.write_bytes(b"weights") + original_stat = weights.stat() + _write_local_download_metadata(checkpoint, "model.safetensors", revision) + weights.write_bytes(b"changed") + os.utime(weights, ns=(original_stat.st_atime_ns, original_stat.st_mtime_ns)) + monkeypatch.setitem( sys.modules, - "huggingface_hub.errors", - types.SimpleNamespace(CachedRepoTreeNotFoundError=missing_metadata), + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), ) - with pytest.raises(RuntimeError, match="missing pinned Hugging Face local-dir metadata"): + with pytest.raises(RuntimeError, match="contents do not match its Hugging Face ETag"): resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) From 72d9f6951cff79fb7b995853795b1d7f91717ac3 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 01:03:51 +0800 Subject: [PATCH 10/25] fix(dpo): verify reference weight manifests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Enforce local reference completeness - Require a supported single-file weight or standard Transformers weight index - Validate non-empty index weight maps, safe shard paths, and format-specific suffixes - Reject indexes that reference missing model shards --- # ✅ Tests ## Cover missing reference weights - Accept a complete multi-shard safetensors index - Reject snapshots without a supported weight entry point - Reject a deleted shard even when its local metadata is also removed --- .../backends/megatron/reference_integrity.py | 38 +++++++++++ .../megatron/test_dpo_reference_integrity.py | 64 +++++++++++++++++++ 2 files changed, 102 insertions(+) diff --git a/relax/backends/megatron/reference_integrity.py b/relax/backends/megatron/reference_integrity.py index 066bea64c..f9b989738 100644 --- a/relax/backends/megatron/reference_integrity.py +++ b/relax/backends/megatron/reference_integrity.py @@ -19,6 +19,11 @@ REFERENCE_LOADER_MODE = "hf_bridge_model_only_v1" _GIT_COMMIT_SHA256_RE = re.compile(r"^[0-9a-f]{40}$") _HF_ETAG_RE = re.compile(r"^(?:[0-9a-f]{40}|[0-9a-f]{64})$") +_WEIGHT_INDEXES = ( + ("model.safetensors.index.json", ".safetensors"), + ("pytorch_model.bin.index.json", ".bin"), +) +_SINGLE_WEIGHT_NAMES = ("model.safetensors", "pytorch_model.bin") def _file_matches_hf_etag(path: Path, etag: str) -> bool: @@ -32,6 +37,38 @@ def _file_matches_hf_etag(path: Path, etag: str) -> bool: return digest.hexdigest() == etag +def _validate_reference_weight_files(checkpoint: Path) -> None: + found_weights = any((checkpoint / filename).is_file() for filename in _SINGLE_WEIGHT_NAMES) + for index_name, shard_suffix in _WEIGHT_INDEXES: + index_path = checkpoint / index_name + if not index_path.is_file(): + continue + found_weights = True + try: + payload = json.loads(index_path.read_text(encoding="utf-8")) + weight_map = payload["weight_map"] + except (OSError, ValueError, KeyError, TypeError) as exc: + raise RuntimeError(f"DPO reference weight index is invalid: {index_name!r}") from exc + if not isinstance(weight_map, Mapping) or not weight_map: + raise RuntimeError(f"DPO reference weight index has an empty weight_map: {index_name!r}") + shard_names = set() + for filename in weight_map.values(): + if not isinstance(filename, str) or not filename: + raise RuntimeError(f"DPO reference weight index contains an invalid shard name: {index_name!r}") + shard_names.add(filename) + for filename in shard_names: + relative_path = Path(filename) + if relative_path.is_absolute() or ".." in relative_path.parts: + raise RuntimeError(f"DPO reference weight index contains an unsafe shard path: {filename!r}") + if relative_path.suffix != shard_suffix: + raise RuntimeError(f"DPO reference weight index contains an invalid shard suffix: {filename!r}") + if not (checkpoint / relative_path).is_file(): + raise RuntimeError(f"DPO reference weight index points to a missing shard: {filename!r}") + if not found_weights: + supported = ", ".join((*_SINGLE_WEIGHT_NAMES, *(name for name, _suffix in _WEIGHT_INDEXES))) + raise RuntimeError(f"DPO reference has no supported model weights or index; expected one of: {supported}") + + def _validate_local_download_metadata(checkpoint: Path, revision: str) -> None: metadata_root = checkpoint / ".cache" / "huggingface" / "download" snapshot_files = [ @@ -101,6 +138,7 @@ def resolve_dpo_reference_checkpoint(repository: str, revision: str, local_check f"repository={repository!r}, revision={revision!r}, path={checkpoint}" ) try: + _validate_reference_weight_files(checkpoint) _validate_local_download_metadata(checkpoint, revision) except RuntimeError as exc: raise RuntimeError( diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py index 24541ac1a..b5022604e 100644 --- a/tests/backends/megatron/test_dpo_reference_integrity.py +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -164,6 +164,7 @@ def test_resolve_dpo_reference_checkpoint_rejects_missing_pinned_local_metadata( checkpoint = tmp_path / "checkpoint" checkpoint.mkdir() (checkpoint / "config.json").write_text("{}", encoding="utf-8") + (checkpoint / "model.safetensors").write_bytes(b"weights") monkeypatch.setitem( sys.modules, "huggingface_hub", @@ -179,6 +180,8 @@ def test_resolve_dpo_reference_checkpoint_rejects_mismatched_file_metadata(monke checkpoint.mkdir() (checkpoint / "config.json").write_text("{}", encoding="utf-8") _write_local_download_metadata(checkpoint, "config.json", "c" * 40) + (checkpoint / "model.safetensors").write_bytes(b"weights") + _write_local_download_metadata(checkpoint, "model.safetensors", revision) monkeypatch.setitem( sys.modules, @@ -212,6 +215,67 @@ def test_resolve_dpo_reference_checkpoint_rejects_replaced_file_with_restored_mt resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) +def test_resolve_dpo_reference_checkpoint_rejects_snapshot_without_supported_weights(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + _write_local_download_metadata(checkpoint, "config.json", revision) + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), + ) + with pytest.raises(RuntimeError, match="no supported model weights or index"): + resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) + + +def test_resolve_dpo_reference_checkpoint_accepts_complete_safetensors_index(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + index_name = "model.safetensors.index.json" + shard_names = ("model-00001-of-00002.safetensors", "model-00002-of-00002.safetensors") + weight_map = {f"layer.{index}.weight": shard for index, shard in enumerate(shard_names)} + (checkpoint / index_name).write_text(json.dumps({"weight_map": weight_map}), encoding="utf-8") + for shard_name in shard_names: + (checkpoint / shard_name).write_bytes(shard_name.encode()) + for filename in ("config.json", index_name, *shard_names): + _write_local_download_metadata(checkpoint, filename, revision) + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), + ) + assert resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) == str(checkpoint.resolve()) + + +def test_resolve_dpo_reference_checkpoint_rejects_missing_indexed_shard_and_metadata(monkeypatch, tmp_path): + revision = "a" * 40 + checkpoint = tmp_path / "checkpoint" + checkpoint.mkdir() + (checkpoint / "config.json").write_text("{}", encoding="utf-8") + index_name = "model.safetensors.index.json" + shard_name = "model-00001-of-00001.safetensors" + (checkpoint / index_name).write_text(json.dumps({"weight_map": {"model.weight": shard_name}}), encoding="utf-8") + (checkpoint / shard_name).write_bytes(b"weights") + for filename in ("config.json", index_name, shard_name): + _write_local_download_metadata(checkpoint, filename, revision) + (checkpoint / shard_name).unlink() + (checkpoint / ".cache" / "huggingface" / "download" / f"{shard_name}.metadata").unlink() + + monkeypatch.setitem( + sys.modules, + "huggingface_hub", + types.SimpleNamespace(snapshot_download=lambda **_kwargs: str(checkpoint)), + ) + with pytest.raises(RuntimeError, match="weight index points to a missing shard"): + resolve_dpo_reference_checkpoint("org/model", revision, str(checkpoint)) + + def test_resume_probe_materializes_manifest_lists_as_tensors(monkeypatch): try: from relax.backends.megatron import actor as actor_module From 6f217702799bde54ecdf9a1a36c91708caa27a14 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 06:32:43 +0800 Subject: [PATCH 11/25] fix(dpo): avoid iterator device readbacks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Move preference scheduling to the CPU control plane - Replace CUDA count reductions and scalar readbacks with one DP-Gloo control gather - Preserve pair-row, global-denominator, and micro-batch-count agreement across ranks - Require Gloo process groups for preference objectives and enable them in the DPO recipe --- # ⚡ Performance ## Remove hot-path GPU synchronization - Eliminate all item calls and control tensors from the preference iterator - Avoid GPU-to-CPU synchronization for train, reference, and evaluation iterators --- # ✅ Tests ## Guard preference iterator contracts - Cover unequal DP pair-row rejection through the Gloo control path - Assert the iterator contains no item or all-reduce scalar readback path --- relax/backends/megatron/data.py | 41 +++++++++---------- relax/engine/sft/runtime.py | 2 + .../dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 1 + .../megatron/test_preference_batching.py | 40 +++++++++++++----- tests/engine/sft/test_preference_runtime.py | 2 + 5 files changed, 54 insertions(+), 32 deletions(-) diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index a04d394a8..66ef35afb 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -792,21 +792,6 @@ def _get_preference_data_iterator( pair_costs = [int(cost) for cost in rollout_data["preference_pair_costs"]] pair_ids = [str(pair_id) for pair_id in rollout_data["preference_pair_ids"]] dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) - dp_group = mpu.get_data_parallel_group() - device = device_utils.make_current_torch_device() - count_tensor = torch.tensor([len(pair_costs)], dtype=torch.int64, device=device) - # MIN and MAX ride a single MAX all_reduce on [count, -count]. - minmax_tensor = torch.tensor([len(pair_costs), -len(pair_costs)], dtype=torch.int64, device=device) - dist.all_reduce(count_tensor, op=dist.ReduceOp.SUM, group=dp_group) - dist.all_reduce(minmax_tensor, op=dist.ReduceOp.MAX, group=dp_group) - step_global_pair_count = int(count_tensor.item()) - global_max = int(minmax_tensor[0].item()) - global_min = -int(minmax_tensor[1].item()) - if global_min != global_max: - raise ValueError( - "preference objectives require equal local pair rows on every DP rank: " - f"global_min={global_min}, global_max={global_max}" - ) dynamic_count = rollout_data.get("dynamic_global_batch_size") if isinstance(dynamic_count, (list, tuple)): normalized = {int(value) for value in dynamic_count} @@ -814,18 +799,30 @@ def _get_preference_data_iterator( raise ValueError(f"dynamic_global_batch_size values must be identical, got {dynamic_count}") dynamic_count = normalized.pop() expected_global_pairs = int(args.global_batch_size) if dynamic_count is None else int(dynamic_count) - if expected_global_pairs != step_global_pair_count: + capacity = int(max_tokens_per_gpu or args.max_tokens_per_gpu) + pair_bins = pack_preference_pair_indices(pair_costs, pair_ids, capacity=capacity) + control_values = [None] * dp_size + dist.all_gather_object( + control_values, + (len(pair_costs), expected_global_pairs, len(pair_bins)), + group=mpu.get_data_parallel_group_gloo(with_context_parallel=False), + ) + local_pair_counts = {int(values[0]) for values in control_values} + if len(local_pair_counts) != 1: + raise ValueError(f"preference objectives require equal local pair rows on every DP rank: {local_pair_counts}") + declared_global_pairs = {int(values[1]) for values in control_values} + if len(declared_global_pairs) != 1: + raise ValueError(f"dynamic_global_batch_size must be identical on every DP rank: {declared_global_pairs}") + step_global_pair_count = local_pair_counts.pop() * dp_size + declared_global_pair_count = declared_global_pairs.pop() + if declared_global_pair_count != step_global_pair_count: raise ValueError( "dynamic_global_batch_size must equal the step-global preference pair count: " - f"declared={expected_global_pairs}, actual={step_global_pair_count}, " + f"declared={declared_global_pair_count}, actual={step_global_pair_count}, " f"local={len(pair_costs)}, dp_size={dp_size}" ) rollout_data["dynamic_global_batch_size"] = step_global_pair_count - capacity = int(max_tokens_per_gpu or args.max_tokens_per_gpu) - pair_bins = pack_preference_pair_indices(pair_costs, pair_ids, capacity=capacity) - bin_count = torch.tensor([len(pair_bins)], dtype=torch.int, device=device) - dist.all_reduce(bin_count, op=dist.ReduceOp.MAX, group=dp_group) - pair_bins = _split_preference_bins_to_count(pair_bins, int(bin_count.item())) + pair_bins = _split_preference_bins_to_count(pair_bins, max(int(values[2]) for values in control_values)) if any(sum(pair_costs[index] for index in group) > capacity for group in pair_bins): raise RuntimeError("preference DP bin synchronization produced an over-capacity micro-batch") branch_bins = [ diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 35fe18c00..792a8b95c 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -53,6 +53,8 @@ def validate_preference_args(args: Namespace) -> None: raise ValueError("preference objectives v1 require --qkv-format thd") if getattr(args, "fully_async", False) or getattr(args, "hybrid", False): raise ValueError("preference objectives v1 support synchronous SFT topology only") + if not getattr(args, "use_gloo_process_groups", False): + raise ValueError("preference objectives require --use-gloo-process-groups for DP iterator control data") if getattr(args, "sft_chunked_logits", False) or getattr(args, "enable_mtp_training", False): raise ValueError("preference objectives v1 do not support SFT chunked logits or MTP") if getattr(args, "calculate_per_token_loss", False): diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index e6ba78d77..2ccd1d2c7 100644 --- a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -45,6 +45,7 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --num-rollout "${NUM_ROLLOUT:-200}" \ --global-batch-size "${GLOBAL_BATCH_SIZE:-32}" \ --use-dynamic-batch-size \ + --use-gloo-process-groups \ --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ --tensor-model-parallel-size 1 \ --pipeline-model-parallel-size 1 \ diff --git a/tests/backends/megatron/test_preference_batching.py b/tests/backends/megatron/test_preference_batching.py index 25b5c6da5..15c027b0b 100644 --- a/tests/backends/megatron/test_preference_batching.py +++ b/tests/backends/megatron/test_preference_batching.py @@ -8,7 +8,6 @@ from pathlib import Path import pytest -import torch try: @@ -53,9 +52,12 @@ def test_capacity_packer_is_deterministic_complete_and_bounded(): def test_preference_iterator_validates_step_global_pair_denominator(monkeypatch): flat = expand_preference_rollout_data(_pair_rows()) monkeypatch.setattr(data_module.mpu, "get_data_parallel_world_size", lambda **kwargs: 1) - monkeypatch.setattr(data_module.mpu, "get_data_parallel_group", lambda: object()) - monkeypatch.setattr(data_module.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) - monkeypatch.setattr(data_module.dist, "all_reduce", lambda tensor, **kwargs: None) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_group_gloo", lambda **kwargs: object()) + + def all_gather_object(output, value, **_kwargs): + output[:] = [value] + + monkeypatch.setattr(data_module.dist, "all_gather_object", all_gather_object) args = Namespace(global_batch_size=2, max_tokens_per_gpu=16) iterators, counts = data_module._get_preference_data_iterator(args, flat, None) assert counts == [1] @@ -71,14 +73,12 @@ def test_preference_iterator_validates_step_global_pair_denominator(monkeypatch) def test_dp2_pair_rows_remain_atomic_with_global_pair_denominator(monkeypatch): flat = expand_preference_rollout_data(_pair_rows()) monkeypatch.setattr(data_module.mpu, "get_data_parallel_world_size", lambda **kwargs: 2) - monkeypatch.setattr(data_module.mpu, "get_data_parallel_group", lambda: object()) - monkeypatch.setattr(data_module.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_group_gloo", lambda **kwargs: object()) - def all_reduce(tensor, *, op, **kwargs): - if op == data_module.dist.ReduceOp.SUM: - tensor.mul_(2) + def all_gather_object(output, value, **_kwargs): + output[:] = [value, value] - monkeypatch.setattr(data_module.dist, "all_reduce", all_reduce) + monkeypatch.setattr(data_module.dist, "all_gather_object", all_gather_object) args = Namespace(global_batch_size=4, max_tokens_per_gpu=4) iterators, counts = data_module._get_preference_data_iterator(args, flat, None) assert flat["dynamic_global_batch_size"] == 4 @@ -92,6 +92,26 @@ def all_reduce(tensor, *, op, **kwargs): assert sorted(seen) == [100, 100, 101, 101] +def test_preference_iterator_has_no_device_scalar_readback(): + source = inspect.getsource(data_module._get_preference_data_iterator) + assert ".item(" not in source + assert "all_reduce(" not in source + + +def test_preference_iterator_rejects_unequal_dp_pair_rows_via_gloo(monkeypatch): + flat = expand_preference_rollout_data(_pair_rows()) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_world_size", lambda **kwargs: 2) + monkeypatch.setattr(data_module.mpu, "get_data_parallel_group_gloo", lambda **kwargs: object()) + + def all_gather_object(output, value, **_kwargs): + output[:] = [value, (value[0] + 1, value[1], value[2])] + + monkeypatch.setattr(data_module.dist, "all_gather_object", all_gather_object) + args = Namespace(global_batch_size=4, max_tokens_per_gpu=16) + with pytest.raises(ValueError, match="equal local pair rows"): + data_module._get_preference_data_iterator(args, flat, None) + + def test_oversize_error_names_pair_cost_and_capacity(): with pytest.raises(ValueError, match=r"oversize preference pair 'pair-x'.*cost 11, capacity=10"): pack_preference_pair_indices([11], ["pair-x"], capacity=10) diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index 8dbd08887..80d8f1941 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -23,6 +23,7 @@ def _args(**overrides) -> Namespace: "qkv_format": "thd", "fully_async": False, "hybrid": False, + "use_gloo_process_groups": True, "sft_chunked_logits": False, "enable_mtp_training": False, "calculate_per_token_loss": False, @@ -64,6 +65,7 @@ def test_preference_mode_is_nested_under_sft(): ({"context_parallel_size": 2}, "TP=CP=PP=1"), ({"dynamic_context_parallel": True}, "dynamic context"), ({"qkv_format": "bshd"}, "qkv-format thd"), + ({"use_gloo_process_groups": False}, "use-gloo-process-groups"), ({"lora_rank": 8}, "LoRA"), ({"hidden_dropout": 0.1}, "dropout"), ({"ref_update_interval": 10}, "frozen reference"), From 0e8c3342bb01cc6a85a6da72a5bf5201d6edeaaf Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 14:56:37 +0800 Subject: [PATCH 12/25] refactor(dpo): remove dead identity builder MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # ♻️ Refactor ## Keep one reference identity path - Remove the unused helper that reads the already-backed-up ref weights - Preserve rebuild validation and backup ordering without duplicate digest work --- # ✅ Tests - Pass the full pre-commit suite - Compile the Megatron actor module --- relax/backends/megatron/actor.py | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index b119649c3..459db7017 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -462,19 +462,6 @@ def _switch_model(self, target_tag: str) -> None: def _is_standard_dpo(self) -> bool: return is_preference_mode(self.args) and self.args.sft_objective == "dpo" and not self.args.dpo_reference_free - def _build_dpo_reference_identity(self, *, probe_sha256: str | None = None) -> DPOReferenceIdentity: - parameter_sha256 = canonical_tensor_sha256(self.weights_backuper.get("ref").items()) - self._assert_dp_reference_digest_equal(parameter_sha256) - return DPOReferenceIdentity( - schema_version=1, - repository=self.args.dpo_reference_repository, - revision=self.args.dpo_reference_revision, - loader_mode=REFERENCE_LOADER_MODE, - parameter_sha256=parameter_sha256, - probe_sha256=probe_sha256, - probe_manifest=None, - ) - def _assert_dp_reference_digest_equal(self, digest: str) -> None: digests = [None] * dist.get_world_size(group=get_gloo_group()) dist.all_gather_object(digests, digest, group=get_gloo_group()) From c3c99023f001fd922b94ef5da22d7aa891236834 Mon Sep 17 00:00:00 2001 From: A-Words Date: Fri, 7 Aug 2026 20:08:06 +0800 Subject: [PATCH 13/25] feat(sft): add reward modeling and preference evaluation --- relax/backends/megatron/data.py | 8 ++ relax/backends/megatron/loss.py | 33 +++++ relax/backends/megatron/model.py | 15 ++- relax/backends/megatron/model_provider.py | 8 +- relax/components/sft.py | 74 +++++++---- relax/engine/sft/bootstrap.py | 2 +- relax/engine/sft/dataset/preference.py | 6 + relax/engine/sft/eval/preference.py | 60 +++++++++ relax/engine/sft/eval/runner.py | 123 ++++++++++++++++++ relax/engine/sft/runtime.py | 52 ++++---- relax/utils/arguments.py | 2 +- relax/utils/training/data_fields.py | 4 +- relax/utils/training/ppo_utils.py | 66 +++++++++- relax/utils/training/preference_utils.py | 50 ++++++- .../dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 3 + .../run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 63 +++++++++ .../megatron/test_model_provider_vpp.py | 31 +++++ .../megatron/test_preference_batching.py | 2 + .../megatron/test_sft_train_data_fields.py | 4 + tests/engine/sft/dataset/test_preference.py | 2 + tests/engine/sft/eval/test_preference.py | 20 +++ tests/engine/sft/test_preference_runtime.py | 18 ++- tests/utils/training/test_preference_utils.py | 35 +++++ 23 files changed, 621 insertions(+), 60 deletions(-) create mode 100644 relax/engine/sft/eval/preference.py create mode 100644 scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh create mode 100644 tests/engine/sft/eval/test_preference.py diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index 66ef35afb..bef8e758a 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -717,6 +717,8 @@ def expand_preference_rollout_data(rollout_data: RolloutBatch) -> RolloutBatch: "rejected_loss_masks", "chosen_total_lengths", "rejected_total_lengths", + "chosen_score_positions", + "rejected_score_positions", ) missing = [key for key in required if key not in rollout_data] if missing: @@ -735,6 +737,7 @@ def expand_preference_rollout_data(rollout_data: RolloutBatch) -> RolloutBatch: "loss_masks": [], "total_lengths": [], "response_lengths": [], + "score_positions": [], "preference_branch_pair_ids": [], "preference_is_chosen": [], } @@ -752,14 +755,18 @@ def expand_preference_rollout_data(rollout_data: RolloutBatch) -> RolloutBatch: tokens = rollout_data[f"{prefix}_tokens"][index] loss_mask = rollout_data[f"{prefix}_loss_masks"][index] total_length = int(rollout_data[f"{prefix}_total_lengths"][index]) + score_position = int(rollout_data[f"{prefix}_score_positions"][index]) if len(tokens) != total_length or len(loss_mask) != total_length: raise ValueError( f"preference pair row {index} {prefix} tensor length does not match declared total_length" ) + if not 0 <= score_position < total_length: + raise ValueError(f"preference pair row {index} {prefix} score position is out of range") flat["tokens"].append(tokens) flat["loss_masks"].append(loss_mask) flat["total_lengths"].append(total_length) flat["response_lengths"].append(total_length) + flat["score_positions"].append(score_position) flat["preference_branch_pair_ids"].append(pair_id) flat["preference_is_chosen"].append(is_chosen) flat["preference_pair_costs"] = pair_costs @@ -1059,6 +1066,7 @@ def log_rollout_data( "preference_pair_ids", "preference_branch_pair_ids", "preference_is_chosen", + "score_positions", ]: continue if args.use_opd and key in OPD_ROLLOUT_LOG_SKIP_FIELDS: diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index b873050ce..9932f7d21 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -37,6 +37,8 @@ build_preference_pair_indices, dpo_pair_loss, require_tensor_condition, + reward_model_pair_loss, + select_packed_sequence_scores, ) from relax.utils.types import RolloutBatch @@ -1286,6 +1288,35 @@ def sequence_sums(token_values) -> torch.Tensor: return loss, metrics +def reward_model_loss_function( + args: Namespace, # noqa: ARG001 + batch: RolloutBatch, + logits: torch.Tensor, + sum_of_sample_mean: Callable[[torch.Tensor], torch.Tensor], # noqa: ARG001 +) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: + """Compute pair-summed Bradley-Terry loss over adjacent chosen/rejected + branches.""" + if len(batch["total_lengths"]) % 2 != 0: + raise ValueError("reward-model micro-batch must contain an even number of chosen/rejected branches") + score_positions = batch.get("score_positions") + if score_positions is None: + raise ValueError("reward-model batch is missing score_positions") + scores = select_packed_sequence_scores(logits, batch["total_lengths"], score_positions) + chosen_scores, rejected_scores = scores[0::2], scores[1::2] + pair_losses = reward_model_pair_loss(chosen_scores, rejected_scores) + margins = chosen_scores - rejected_scores + loss = pair_losses.sum() + if pair_losses.numel() == 0: + loss = loss + 0 * logits.sum() + return loss, { + "loss": pair_losses.detach().sum(), + "rm_chosen_score": chosen_scores.detach().sum(), + "rm_rejected_score": rejected_scores.detach().sum(), + "rm_margin": margins.detach().sum(), + "rm_pair_accuracy": (margins > 0).to(torch.float32).detach().sum(), + } + + def sft_loss_function_chunked( args: Namespace, batch: RolloutBatch, @@ -1410,6 +1441,8 @@ def loss_function( case "sft": if getattr(args, "sft_objective", "causal_lm") == "dpo": func = dpo_loss_function + elif getattr(args, "sft_objective", "causal_lm") == "reward_model": + func = reward_model_loss_function elif getattr(args, "sft_chunked_logits", False) and lm_head_forward is not None: # Bind lm_head_forward so chunked path matches the standard # inner-func signature; outer body (recompute, CP guard, diff --git a/relax/backends/megatron/model.py b/relax/backends/megatron/model.py index b80bd307b..6dec243c0 100644 --- a/relax/backends/megatron/model.py +++ b/relax/backends/megatron/model.py @@ -26,7 +26,7 @@ from megatron.training.training import get_model from relax.backends.megatron.checkpoint import _save_lora_to_checkpoint -from relax.engine.sft.runtime import is_sft_mode +from relax.engine.sft.runtime import is_preference_mode, is_sft_mode from relax.utils import tracking_utils from relax.utils.data.stream_dataloader import StreamingTQIterator from relax.utils.logging_utils import get_logger @@ -39,6 +39,7 @@ maybe_verify_critic_value_head_movement, release_critic_lm_heads, validate_critic_value_head_registration, + validate_reward_model_head_registration, ) from .checkpoint import load_checkpoint, save_checkpoint @@ -721,6 +722,7 @@ def forward_step( "multimodal_train_inputs", "total_lengths", "response_lengths", + "score_positions", "max_seq_lens", ], args.data_pad_size_multiplier, @@ -801,6 +803,7 @@ def forward_step( max_seq_lens=batch.get("max_seq_lens", None), padded_total_lengths=batch.get("padded_total_lengths", None), loss_masks=batch.get("loss_masks", None), + score_positions=batch.get("score_positions", None), dynamic_cp_size=batch.get("dynamic_cp_size", None), dynamic_cp_rank=batch.get("dynamic_cp_rank", None), ) @@ -984,6 +987,7 @@ def forward_step( "values", "advantages", "returns", + "score_positions", "rollout_log_probs", "max_seq_lens", *_opd_keys, @@ -1578,8 +1582,11 @@ def initialize_model_and_optimizer( model, optimizer, opt_param_scheduler = setup_model_and_optimizer(args, role) model[0].role = role value_head_param_ids = () + reward_head_param_ids = () if role == "critic": value_head_param_ids = validate_critic_value_head_registration(model, optimizer) + elif is_preference_mode(args) and args.sft_objective == "reward_model": + reward_head_param_ids = validate_reward_model_head_registration(model, optimizer) clear_memory() iteration, _ = load_checkpoint( model, @@ -1595,6 +1602,12 @@ def initialize_model_and_optimizer( "critic value head parameter identities changed during checkpoint loading" ) install_critic_value_head_runtime_check(model) + elif is_preference_mode(args) and args.sft_objective == "reward_model": + release_critic_lm_heads(model) + loaded_reward_head_param_ids = validate_reward_model_head_registration(model, optimizer) + assert loaded_reward_head_param_ids == reward_head_param_ids, ( + "reward-model head parameter identities changed during checkpoint loading" + ) clear_memory() if opt_param_scheduler is not None: opt_param_scheduler.step(increment=iteration * args.global_batch_size) diff --git a/relax/backends/megatron/model_provider.py b/relax/backends/megatron/model_provider.py index 7e9805608..a5d031786 100644 --- a/relax/backends/megatron/model_provider.py +++ b/relax/backends/megatron/model_provider.py @@ -27,7 +27,10 @@ from relax.utils.logging_utils import get_logger from relax.utils.megatron_peft_utils import build_lora_peft, count_adapter_parameters, is_lora_enabled from relax.utils.misc import load_function -from relax.utils.training.ppo_utils import install_critic_value_head_in_provider +from relax.utils.training.ppo_utils import ( + install_critic_value_head_in_provider, + install_reward_model_head_in_provider, +) from .conditional_branch_sync import install_conditional_branch_sync @@ -197,6 +200,7 @@ def wrapped_model_provider( model = custom_model_provider(pre_process=pre_process, post_process=post_process) # Apply critic output layer if needed install_critic_value_head_in_provider(model, role, post_process) + install_reward_model_head_in_provider(model, args, role, post_process) _maybe_mark_unsplit_forward(args, model) install_conditional_branch_sync(args, model) _install_cp_probe(model) @@ -327,6 +331,7 @@ def provide_with_cp_probe(*p_args, **p_kwargs): model = original_provide(*p_args, **p_kwargs) post_process = p_kwargs.get("post_process", p_args[1] if len(p_args) > 1 else True) install_critic_value_head_in_provider(model, role, post_process, stash_lm_head=True) + install_reward_model_head_in_provider(model, args, role, post_process, stash_lm_head=True) _maybe_mark_unsplit_forward(args, model) install_conditional_branch_sync(args, model) _install_cp_probe(model) @@ -440,6 +445,7 @@ def model_provider(pre_process: bool = True, post_process: bool = True, vp_stage model = GPTModel(**kwargs) install_critic_value_head_in_provider(model, role, post_process) + install_reward_model_head_in_provider(model, args, role, post_process) _maybe_mark_unsplit_forward(args, model) install_conditional_branch_sync(args, model) diff --git a/relax/components/sft.py b/relax/components/sft.py index d6c611759..1609dabe0 100644 --- a/relax/components/sft.py +++ b/relax/components/sft.py @@ -211,26 +211,46 @@ def _init_data_pipeline(self) -> None: eval_tool_key = getattr(self.config, "eval_tool_key", None) or self.config.tool_key # Eval is small + runs every `eval_interval`; disable prefetch so # we don't consume worker threads idly between eval rounds. - self._eval_dataset = SFTStreamingDataset( - path=[d.path for d in eval_prompt_data], - tokenizer=self._tokenizer, - processor_pool=self._processor_pool, - capacity=capacity, - prompt_key=eval_input_key, - label_key=eval_label_key, - multimodal_keys=self.config.multimodal_keys, - conversation_key_map=getattr(self.config, "conversation_key_map", None), - metadata_key=self.config.metadata_key, - tool_key=eval_tool_key, - system_prompt=self.config.system_prompt, - source_name="+".join(d.name for d in eval_prompt_data), - seed=seed, - prefetch_max_cached=0, - pad_token_ids=pad_token_ids, - oversize_strategy=oversize_strategy, - oversize_custom_fn=oversize_custom_fn, - apply_chat_template_kwargs=getattr(self.config, "apply_chat_template_kwargs", None), - ) + if is_preference_mode(self.config): + self._eval_dataset = PreferenceStreamingDataset( + path=[d.path for d in eval_prompt_data], + tokenizer=self._tokenizer, + prompt_key=eval_input_key, + chosen_key=self.config.preference_chosen_key, + rejected_key=self.config.preference_rejected_key, + pair_id_key=self.config.preference_pair_id_key, + metadata_key=self.config.metadata_key, + source_name="+".join(d.name for d in eval_prompt_data), + max_length=self.config.preference_max_length, + max_completion_length=self.config.preference_max_completion_length, + pair_capacity=capacity, + seed=seed, + prefetch_max_cached=0, + apply_chat_template_kwargs=getattr(self.config, "apply_chat_template_kwargs", None), + expected_chat_template_sha256=self.config.preference_chat_template_sha256, + require_no_generation_marker=self.config.preference_require_no_generation_marker, + ) + else: + self._eval_dataset = SFTStreamingDataset( + path=[d.path for d in eval_prompt_data], + tokenizer=self._tokenizer, + processor_pool=self._processor_pool, + capacity=capacity, + prompt_key=eval_input_key, + label_key=eval_label_key, + multimodal_keys=self.config.multimodal_keys, + conversation_key_map=getattr(self.config, "conversation_key_map", None), + metadata_key=self.config.metadata_key, + tool_key=eval_tool_key, + system_prompt=self.config.system_prompt, + source_name="+".join(d.name for d in eval_prompt_data), + seed=seed, + prefetch_max_cached=0, + pad_token_ids=pad_token_ids, + oversize_strategy=oversize_strategy, + oversize_custom_fn=oversize_custom_fn, + apply_chat_template_kwargs=getattr(self.config, "apply_chat_template_kwargs", None), + ) # Resume: align IndexManager with `start_rollout_id` so a restart sees # the same shuffled order it would on a fresh run. @@ -436,9 +456,16 @@ async def _maybe_produce_eval(self) -> None: f"interpret with caution." ) - backend_batch = pack_samples_for_tq(samples, force_multimodal_field=self.config.multimodal_keys is not None) + if is_preference_mode(self.config): + backend_batch, preference_custom_meta = pack_preference_pairs_for_tq(samples) + else: + backend_batch = pack_samples_for_tq( + samples, force_multimodal_field=self.config.multimodal_keys is not None + ) + preference_custom_meta = None assert backend_batch is not None - n_samples = len(backend_batch["tokens"]) + row_key = "pair_ids" if is_preference_mode(self.config) else "tokens" + n_samples = len(backend_batch[row_key]) # Drain the current train partition so the eval chunks have the full # TQ capacity to themselves. @@ -480,8 +507,9 @@ async def _maybe_produce_eval(self) -> None: chunk = {k: v[s:e] for k, v in backend_batch.items()} partition_id = f"sft_eval_{self.step}_n{n_chunks}_{chunk_idx}" await self.data_system_client.async_put( - data=dict_to_tensordict(chunk, batch_size=len(chunk["tokens"])), + data=dict_to_tensordict(chunk, batch_size=len(chunk[row_key])), partition_id=partition_id, + custom_meta=None if preference_custom_meta is None else preference_custom_meta[s:e], ) drained = await self._wait_for_partition_drained(partition_id, timeout_sec=chunk_drain_timeout) if not drained: diff --git a/relax/engine/sft/bootstrap.py b/relax/engine/sft/bootstrap.py index b22c7e55e..bd953f20a 100644 --- a/relax/engine/sft/bootstrap.py +++ b/relax/engine/sft/bootstrap.py @@ -58,7 +58,7 @@ def resolve_sft_num_rollout(config: Namespace) -> None: # Lazy import: pulling streaming dataset at module load would drag heavy # multimodal deps into every controller import. - if getattr(config, "sft_objective", "causal_lm") == "dpo": + if getattr(config, "sft_objective", "causal_lm") in {"dpo", "reward_model"}: from relax.engine.sft.dataset.preference import PreferenceStreamingDataset sizing_dataset = PreferenceStreamingDataset( diff --git a/relax/engine/sft/dataset/preference.py b/relax/engine/sft/dataset/preference.py index 3f154a4f4..a68eec2fe 100644 --- a/relax/engine/sft/dataset/preference.py +++ b/relax/engine/sft/dataset/preference.py @@ -88,6 +88,8 @@ class ProcessedPreferencePair: rejected_prompt_length: int chosen_completion_length: int rejected_completion_length: int + chosen_score_position: int + rejected_score_position: int source_idx: int @property @@ -417,6 +419,8 @@ def _get_processed_pair(self, idx: int) -> ProcessedPreferencePair: rejected_prompt_length=prompt.numel(), chosen_completion_length=chosen_completion.numel(), rejected_completion_length=rejected_completion.numel(), + chosen_score_position=chosen_tokens.numel() - 1, + rejected_score_position=rejected_tokens.numel() - 1, source_idx=idx, ) @@ -518,6 +522,8 @@ def pack_preference_pairs_for_tq( "rejected_loss_masks": [pair.rejected_loss_mask.tolist() for pair in pairs], "chosen_total_lengths": [pair.chosen_total_length for pair in pairs], "rejected_total_lengths": [pair.rejected_total_length for pair in pairs], + "chosen_score_positions": [pair.chosen_score_position for pair in pairs], + "rejected_score_positions": [pair.rejected_score_position for pair in pairs], } custom_meta = [{"total_lengths": pair.pair_total_length} for pair in pairs] if len(custom_meta) != len(pairs): diff --git a/relax/engine/sft/eval/preference.py b/relax/engine/sft/eval/preference.py new file mode 100644 index 000000000..0aae061c8 --- /dev/null +++ b/relax/engine/sft/eval/preference.py @@ -0,0 +1,60 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Forward-only callbacks and reducers for held-out preference evaluation.""" + +import torch + +from relax.utils.training.preference_utils import select_packed_sequence_scores + + +def compute_reward_model_eval_step( + logits: torch.Tensor, + *, + total_lengths, + score_positions=None, + **_, +) -> tuple[torch.Tensor, dict[str, list[torch.Tensor]]]: + if score_positions is None: + raise ValueError("reward-model eval batch is missing score_positions") + scores = select_packed_sequence_scores(logits, total_lengths, score_positions).detach() + return torch.empty((0,), device=logits.device), {"scores": [scores]} + + +def pair_metric_sums(chosen: torch.Tensor, rejected: torch.Tensor, losses: torch.Tensor) -> torch.Tensor: + """Return additive loss/count/score/margin/correct/tie statistics.""" + if chosen.shape != rejected.shape or chosen.shape != losses.shape: + raise ValueError("preference eval tensors must have identical shapes") + margin = chosen - rejected + epsilon = 1e-6 + correct = (margin > epsilon).to(torch.float64).sum() + ties = (margin.abs() <= epsilon).to(torch.float64).sum() + return torch.stack( + [ + losses.to(torch.float64).sum(), + torch.tensor(float(losses.numel()), device=losses.device, dtype=torch.float64), + chosen.to(torch.float64).sum(), + rejected.to(torch.float64).sum(), + margin.to(torch.float64).sum(), + correct, + ties, + ] + ) + + +def finalize_pair_metrics(values: torch.Tensor, *, prefix: str) -> dict[str, float]: + loss_sum, count, chosen_sum, rejected_sum, margin_sum, correct, ties = values.tolist() + if count <= 0: + raise ValueError("preference evaluator received zero pairs") + return { + f"eval/{prefix}_loss": loss_sum / count, + f"eval/{prefix}_chosen": chosen_sum / count, + f"eval/{prefix}_rejected": rejected_sum / count, + f"eval/{prefix}_margin": margin_sum / count, + f"eval/{prefix}_strict_accuracy": correct / count, + f"eval/{prefix}_tie_rate": ties / count, + f"eval/{prefix}_tie_aware_accuracy": (correct + 0.5 * ties) / count, + f"eval/{prefix}_pairs": count, + } + + +__all__ = ["compute_reward_model_eval_step", "finalize_pair_metrics", "pair_metric_sums"] diff --git a/relax/engine/sft/eval/runner.py b/relax/engine/sft/eval/runner.py index 3a9897292..f943a3695 100644 --- a/relax/engine/sft/eval/runner.py +++ b/relax/engine/sft/eval/runner.py @@ -98,6 +98,12 @@ def run_sft_eval(actor, rollout_id: int) -> None: loss mask), and the final all-reduce below includes the CP group so each rank ends up with the full-sequence totals. """ + from relax.engine.sft.runtime import is_preference_mode + + if is_preference_mode(actor.args): + _run_preference_eval(actor, rollout_id) + return + # Lazy imports: keep this module importable without Megatron initialized. from relax.backends.megatron.data import get_data_iterator from relax.backends.megatron.initialize import is_megatron_main_rank @@ -181,3 +187,120 @@ def run_sft_eval(actor, rollout_id: int) -> None: # step) and never reach ClearML/W&B/TB. tracking_utils.flush_metrics(args, step) logger.info(f"SFT eval @ rollout_id={rollout_id}: {metrics}") + + +def _run_preference_eval(actor, rollout_id: int) -> None: + """Evaluate DPO or RM on pair rows using the same TQ packing as + training.""" + from relax.backends.megatron.data import expand_preference_rollout_data, get_data_iterator + from relax.backends.megatron.initialize import is_megatron_main_rank + from relax.backends.megatron.model import forward_only + from relax.engine.sft.eval.preference import ( + compute_reward_model_eval_step, + finalize_pair_metrics, + pair_metric_sums, + ) + from relax.utils.training.preference_utils import dpo_pair_loss, reward_model_pair_loss + + args = actor.args + task_name = "sft_eval" + batch_size = args.global_batch_size // mpu.get_data_parallel_world_size(with_context_parallel=False) + data_fields = [ + "pair_ids", + "chosen_tokens", + "rejected_tokens", + "chosen_loss_masks", + "rejected_loss_masks", + "chosen_total_lengths", + "rejected_total_lengths", + "chosen_score_positions", + "rejected_score_positions", + ] + n_chunks = _wait_for_eval_chunk_count(actor, rollout_id) + local = torch.zeros(7, device=device_utils.make_current_torch_device(), dtype=torch.float64) + started = time.monotonic() + with timer("preference_eval"): + for chunk_idx in range(n_chunks): + partition_id = f"sft_eval_{rollout_id}_n{n_chunks}_{chunk_idx}" + _wait_for_eval_partition_present(actor, partition_id) + batch_index = 0 + while not actor.all_consumed(task_name, rollout_id, partition_id=partition_id): + pair_rows, _batch_meta = actor._get_data_from_transfer_queue( + task_name, rollout_id, data_fields, batch_size, batch_index, partition_id=partition_id + ) + if pair_rows is None: + continue + batch_index += 1 + rollout_data = expand_preference_rollout_data(pair_rows) + data_iterator, num_microbatches = get_data_iterator(args, actor.model, rollout_data) + if args.sft_objective == "dpo": + if args.dpo_reference_free: + reference_sums = None + else: + actor._switch_model("ref") + reference = actor.compute_log_prob(data_iterator, num_microbatches, store_prefix="ref_")[ + "ref_log_probs" + ] + reference_sums = _masked_sequence_sums(reference, rollout_data["loss_masks"], local.device) + actor._switch_model("actor") + policy = actor.compute_log_prob(data_iterator, num_microbatches, store_prefix="")["log_probs"] + policy_sums = _masked_sequence_sums(policy, rollout_data["loss_masks"], local.device) + policy_chosen, policy_rejected = policy_sums[0::2], policy_sums[1::2] + if reference_sums is None: + reference_chosen = reference_rejected = None + chosen_values = args.dpo_beta * policy_chosen + rejected_values = args.dpo_beta * policy_rejected + else: + reference_chosen, reference_rejected = reference_sums[0::2], reference_sums[1::2] + chosen_values = args.dpo_beta * (policy_chosen - reference_chosen) + rejected_values = args.dpo_beta * (policy_rejected - reference_rejected) + losses = dpo_pair_loss( + policy_chosen, + policy_rejected, + reference_chosen=reference_chosen, + reference_rejected=reference_rejected, + beta=args.dpo_beta, + reference_free=args.dpo_reference_free, + ) + local += pair_metric_sums(chosen_values, rejected_values, losses) + else: + outputs = forward_only( + compute_reward_model_eval_step, + args, + actor.model, + data_iterator, + num_microbatches, + store_prefix="", + ) + if mpu.is_pipeline_last_stage(): + scores = torch.cat(outputs["scores"]).to(local.device) + chosen_scores, rejected_scores = scores[0::2], scores[1::2] + losses = reward_model_pair_loss(chosen_scores, rejected_scores) + local += pair_metric_sums(chosen_scores, rejected_scores, losses) + dist.barrier(group=get_gloo_group()) + if dist.get_rank() == 0: + run(actor.data_system_client.async_clear_partition(partition_id=partition_id)) + + dist.all_reduce(local, op=dist.ReduceOp.SUM, group=mpu.get_pipeline_model_parallel_group()) + dist.all_reduce(local, op=dist.ReduceOp.SUM, group=mpu.get_data_parallel_group(with_context_parallel=True)) + metrics = finalize_pair_metrics(local, prefix="dpo" if args.sft_objective == "dpo" else "rm") + metrics["perf/preference_eval_time"] = time.monotonic() - started + if is_megatron_main_rank(): + step = compute_rollout_step(args, rollout_id) + metrics["rollout/step"] = step + tracking_utils.log(args, metrics, step_key="rollout/step") + tracking_utils.flush_metrics(args, step) + logger.info(f"Preference eval @ rollout_id={rollout_id}: {metrics}") + + +def _masked_sequence_sums(values, masks, device: torch.device) -> torch.Tensor: + if len(values) != len(masks): + raise ValueError("preference eval values/masks are not branch aligned") + sums = [] + for value, mask in zip(values, masks, strict=True): + value = torch.as_tensor(value, device=device) + mask = torch.as_tensor(mask, device=device, dtype=value.dtype) + if value.shape != mask.shape: + raise ValueError(f"preference eval value/mask shape mismatch: {value.shape} vs {mask.shape}") + sums.append((value * mask).sum()) + return torch.stack(sums) diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 792a8b95c..668231168 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -26,13 +26,14 @@ def sft_objective(args: Namespace) -> str: def is_preference_mode(args: Namespace) -> bool: - return is_sft_mode(args) and sft_objective(args) == "dpo" + return is_sft_mode(args) and sft_objective(args) in {"dpo", "reward_model"} def validate_preference_args(args: Namespace) -> None: """Reject unsupported preference configurations before Serve starts.""" if not is_preference_mode(args): return + objective = sft_objective(args) if getattr(args, "custom_dataset_class_path", None): raise ValueError("preference objectives do not support --custom-dataset-class") if getattr(args, "multimodal_keys", None) is not None: @@ -77,29 +78,32 @@ def validate_preference_args(args: Namespace) -> None: seq_length = int(getattr(args, "seq_length", max_length) or max_length) if max_length > seq_length: raise ValueError("--preference-max-length must not exceed --seq-length") - if bool(getattr(args, "eval_prompt_data", None)) or getattr(args, "eval_size", None) is not None: - raise ValueError("DPO held-out evaluation is delivered by the follow-up reward-modeling PR") - beta = float(getattr(args, "dpo_beta", 0.1)) - if not math.isfinite(beta) or beta <= 0: - raise ValueError(f"--dpo-beta must be finite and positive, got {beta}") - likelihood_temperature = float(getattr(args, "rollout_temperature", 1.0)) - if not math.isfinite(likelihood_temperature) or likelihood_temperature != 1.0: - raise ValueError( - "preference objectives require --rollout-temperature 1.0 so sampling temperature does not scale " - "policy/reference likelihood logits" - ) - if getattr(args, "ref_load", None) is not None: - raise ValueError( - "preference objectives do not use --ref-load: standard DPO snapshots the frozen reference " - "from the pinned --dpo-reference-repository/--dpo-reference-revision snapshot" - ) - if not getattr(args, "dpo_reference_free", False) and getattr(args, "ref_update_interval", None) is not None: - raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") - if not getattr(args, "dpo_reference_free", False) and not getattr(args, "enable_weights_backuper", False): - raise ValueError("standard DPO requires --enable-weights-backuper for actor/ref snapshots") - if not getattr(args, "dpo_reference_free", False): - if not getattr(args, "dpo_reference_repository", None) or not getattr(args, "dpo_reference_revision", None): - raise ValueError("standard DPO requires --dpo-reference-repository and --dpo-reference-revision") + if objective != "dpo" and getattr(args, "dpo_reference_free", False): + raise ValueError("--dpo-reference-free is valid only with --sft-objective dpo") + if objective == "dpo": + beta = float(getattr(args, "dpo_beta", 0.1)) + if not math.isfinite(beta) or beta <= 0: + raise ValueError(f"--dpo-beta must be finite and positive, got {beta}") + likelihood_temperature = float(getattr(args, "rollout_temperature", 1.0)) + if not math.isfinite(likelihood_temperature) or likelihood_temperature != 1.0: + raise ValueError( + "DPO requires --rollout-temperature 1.0 so sampling temperature does not scale " + "policy/reference likelihood logits" + ) + if getattr(args, "ref_load", None) is not None: + raise ValueError( + "DPO objectives do not use --ref-load: standard DPO snapshots the frozen reference " + "from the pinned --dpo-reference-repository/--dpo-reference-revision snapshot" + ) + if not getattr(args, "dpo_reference_free", False) and getattr(args, "ref_update_interval", None) is not None: + raise ValueError("standard DPO requires a frozen reference and rejects --ref-update-interval") + if not getattr(args, "dpo_reference_free", False) and not getattr(args, "enable_weights_backuper", False): + raise ValueError("standard DPO requires --enable-weights-backuper for actor/ref snapshots") + if not getattr(args, "dpo_reference_free", False): + if not getattr(args, "dpo_reference_repository", None) or not getattr( + args, "dpo_reference_revision", None + ): + raise ValueError("standard DPO requires --dpo-reference-repository and --dpo-reference-revision") def sft_partition_id(args: Namespace, step: int) -> str: diff --git a/relax/utils/arguments.py b/relax/utils/arguments.py index 176c7891b..88e248728 100644 --- a/relax/utils/arguments.py +++ b/relax/utils/arguments.py @@ -465,7 +465,7 @@ def add_train_arguments(parser): # ---- SFT / Predict ---- parser.add_argument( "--sft-objective", - choices=["causal_lm", "dpo"], + choices=["causal_lm", "dpo", "reward_model"], default="causal_lm", help="Offline objective under --loss-type sft. Defaults to the existing causal-LM behavior.", ) diff --git a/relax/utils/training/data_fields.py b/relax/utils/training/data_fields.py index 101a5d7ba..752a0cc62 100644 --- a/relax/utils/training/data_fields.py +++ b/relax/utils/training/data_fields.py @@ -27,7 +27,7 @@ def build_data_fields(args: Namespace, *, consumer: str = "actor") -> list[str]: ``actor``); other algorithms ignore it and receive the base rollout fields. """ if getattr(args, "loss_type", None) == "sft": - if getattr(args, "sft_objective", "causal_lm") == "dpo": + if getattr(args, "sft_objective", "causal_lm") in {"dpo", "reward_model"}: return [ "pair_ids", "chosen_tokens", @@ -36,6 +36,8 @@ def build_data_fields(args: Namespace, *, consumer: str = "actor") -> list[str]: "rejected_loss_masks", "chosen_total_lengths", "rejected_total_lengths", + "chosen_score_positions", + "rejected_score_positions", ] fields = ["tokens", "total_lengths", "response_lengths", "loss_masks"] if args.multimodal_keys is not None: diff --git a/relax/utils/training/ppo_utils.py b/relax/utils/training/ppo_utils.py index e54c5cf48..ef403edf4 100644 --- a/relax/utils/training/ppo_utils.py +++ b/relax/utils/training/ppo_utils.py @@ -1023,9 +1023,45 @@ def install_critic_value_head_in_provider( ) +def install_reward_model_head_in_provider( + model: torch.nn.Module, + args, + role: str, + post_process: bool, + *, + stash_lm_head: bool = False, +) -> None: + """Install the offline reward-model scalar head before DDP/optimizer + construction.""" + if ( + role != "actor" + or not post_process + or getattr(args, "loss_type", None) != "sft" + or getattr(args, "sft_objective", "causal_lm") != "reward_model" + ): + return + + owner = _find_output_layer_owner(model) + if owner is None: + return + + output_layer = owner.output_layer + if isinstance(output_layer, LinearForLastLayer) and output_layer.out_features == 1: + return + + if stash_lm_head: + object.__setattr__(owner, _RELAX_HF_OUTPUT_LAYER_ATTR, output_layer) + owner.output_layer = LinearForLastLayer( + input_size=owner.config.hidden_size, + output_size=1, + config=owner.config, + bias=False, + ) + + @contextlib.contextmanager def use_critic_lm_head_for_hf_load(model): - """Temporarily restore the stashed LM head for HF Bridge weight loading. + """Temporarily restore a stashed LM head for HF Bridge weight loading. Bridge can only convert HF weights against a vocab-sized ``output_layer``; the scalar value head is put back in ``finally`` (asserting the exact same @@ -1052,9 +1088,9 @@ def use_critic_lm_head_for_hf_load(model): for owner, value_head, value_param_ids in reversed(restored_heads): owner.output_layer = value_head object.__delattr__(owner, _RELAX_HF_OUTPUT_LAYER_ATTR) - assert owner.output_layer is value_head, "critic value head object changed during HF checkpoint loading" + assert owner.output_layer is value_head, "scalar head object changed during HF checkpoint loading" assert tuple(id(param) for param in value_head.parameters()) == value_param_ids, ( - "critic value head parameters changed during HF checkpoint loading" + "scalar head parameters changed during HF checkpoint loading" ) @@ -1118,6 +1154,30 @@ def validate_critic_value_head_registration(model, optimizer) -> tuple[int, ...] return tuple(value_head_param_ids) +def validate_reward_model_head_registration(model, optimizer) -> tuple[int, ...]: + """Validate RM scalar-head shape, bias contract, registration, and DDP + ownership.""" + del optimizer + parameter_ids = [] + for model_chunk in model: + owner = _find_output_layer_owner(model_chunk) + if owner is None: + continue + head = owner.output_layer + assert isinstance(head, LinearForLastLayer), ( + f"reward-model output layer must be LinearForLastLayer, got {type(head).__name__}" + ) + assert tuple(head.weight.shape) == (1, owner.config.hidden_size), ( + f"reward-model head weight must have shape (1, {owner.config.hidden_size}), got {tuple(head.weight.shape)}" + ) + assert head.bias is None, "reward-model scalar head must use bias=False" + registered_parameter_ids = {id(parameter) for parameter in model_chunk.parameters()} + assert id(head.weight) in registered_parameter_ids, "reward-model output_layer.weight is not registered" + assert _ddp_owns_param(model_chunk, head.weight), "DDP does not own reward-model output_layer.weight" + parameter_ids.append(id(head.weight)) + return tuple(parameter_ids) + + def snapshot_critic_value_head_state(model) -> dict: """One-scalar-per-param snapshot of value head weights, keyed by chunk+name. diff --git a/relax/utils/training/preference_utils.py b/relax/utils/training/preference_utils.py index b0df6d939..615049a11 100644 --- a/relax/utils/training/preference_utils.py +++ b/relax/utils/training/preference_utils.py @@ -1,6 +1,6 @@ # Copyright (c) 2026 Relax Authors. All Rights Reserved. -"""Pure helpers for pair-aware DPO training.""" +"""Pure helpers shared by DPO and pairwise reward-model training.""" from collections.abc import Sequence @@ -108,6 +108,52 @@ def build_preference_pair_indices( return chosen_indices, rejected_indices +def reward_model_pair_loss(chosen_scores: torch.Tensor, rejected_scores: torch.Tensor) -> torch.Tensor: + """Return unreduced Bradley-Terry loss, one value per preference pair.""" + _validate_same_shape("reward-model scores", chosen_scores, rejected_scores) + margins = chosen_scores - rejected_scores + if not torch.isfinite(margins).all(): + raise ValueError("reward-model margins must contain only finite values") + return -F.logsigmoid(margins) + + +def select_packed_sequence_scores( + logits: torch.Tensor, + total_lengths: Sequence[int], + score_positions: Sequence[int], +) -> torch.Tensor: + """Select one scalar score per sequence from a CP=1 THD packed output.""" + if len(total_lengths) != len(score_positions): + raise ValueError( + f"total_lengths/score_positions length mismatch: {len(total_lengths)} vs {len(score_positions)}" + ) + if logits.ndim == 3 and logits.shape[0] == 1 and logits.shape[-1] == 1: + flat_logits = logits[0, :, 0] + elif logits.ndim == 2 and logits.shape[-1] == 1: + flat_logits = logits[:, 0] + elif logits.ndim == 1: + flat_logits = logits + else: + raise ValueError(f"reward-model logits must have shape [1,T,1], [T,1], or [T], got {tuple(logits.shape)}") + + offsets: list[int] = [] + cursor = 0 + for index, (length, position) in enumerate(zip(total_lengths, score_positions, strict=True)): + length = int(length) + position = int(position) + if length <= 0: + raise ValueError(f"sequence {index} has non-positive total length {length}") + if not 0 <= position < length: + raise ValueError(f"sequence {index} score position {position} is outside [0, {length})") + offsets.append(cursor + position) + cursor += length + if cursor > flat_logits.numel(): + raise ValueError(f"packed reward logits contain {flat_logits.numel()} tokens, expected at least {cursor}") + if not offsets: + return flat_logits.new_empty((0,)) + return flat_logits[torch.tensor(offsets, device=flat_logits.device, dtype=torch.long)] + + def pack_preference_pair_indices( costs: Sequence[int], pair_ids: Sequence[str], @@ -153,4 +199,6 @@ def pack_preference_pair_indices( "dpo_pair_loss", "pack_preference_pair_indices", "require_tensor_condition", + "reward_model_pair_loss", + "select_packed_sequence_scores", ] diff --git a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index 2ccd1d2c7..b83a5553c 100644 --- a/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/dpo/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -14,6 +14,7 @@ source "${MODEL_CONFIG_DIR}/qwen3-0.6B.sh" MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca HF_CHECKPOINT="${HF_CHECKPOINT:-${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}}" PROMPT_DATA="${PROMPT_DATA:?set PROMPT_DATA to the Task 31 train JSONL or Parquet}" +EVAL_PROMPT_DATA="${EVAL_PROMPT_DATA:?set EVAL_PROMPT_DATA to the Task 31 held-out JSONL or Parquet}" SAVE_DIR="${SAVE_DIR:-${SCRIPT_DIR}/../../../checkpoints/task31-dpo}" EXP_NAME="${EXP_NAME:-qwen3-0.6b-ultrafeedback-dpo-gpu1}" now=$(date "+%Y-%m-%d-%H:%M:%S") @@ -30,6 +31,8 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --dpo-reference-repository Qwen/Qwen3-0.6B \ --dpo-reference-revision "${MODEL_REVISION}" \ --prompt-data "${PROMPT_DATA}" \ + --eval-prompt-data task31 "${EVAL_PROMPT_DATA}" \ + --eval-interval "${EVAL_INTERVAL:-200}" \ --input-key prompt \ --preference-pair-id-key prompt_id \ --preference-max-length 1024 \ diff --git a/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh new file mode 100644 index 000000000..cbfa10916 --- /dev/null +++ b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -0,0 +1,63 @@ +#!/bin/bash + +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +set -eo pipefail +set -x + +SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &>/dev/null && pwd)" +if [ -z "${RELAX_ENTRYPOINT_MODE:-}" ]; then + source "${SCRIPT_DIR}/../../entrypoint/local.sh" +fi +source "${MODEL_CONFIG_DIR}/qwen3-0.6B.sh" + +MODEL_REVISION=c1899de289a04d12100db370d81485cdf75e47ca +HF_CHECKPOINT="${HF_CHECKPOINT:-${MODEL_DIR}/Qwen3-0.6B-${MODEL_REVISION}}" +PROMPT_DATA="${PROMPT_DATA:?set PROMPT_DATA to the Task 31 train JSONL or Parquet}" +EVAL_PROMPT_DATA="${EVAL_PROMPT_DATA:?set EVAL_PROMPT_DATA to the Task 31 held-out JSONL or Parquet}" +SAVE_DIR="${SAVE_DIR:-${SCRIPT_DIR}/../../../checkpoints/task31-reward-modeling}" +EXP_NAME="${EXP_NAME:-qwen3-0.6b-ultrafeedback-rm-gpu1}" +now=$(date "+%Y-%m-%d-%H:%M:%S") + +mkdir -p log "${SAVE_DIR}" +ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ + ${WORKING_DIR:+--working-dir "${WORKING_DIR}"} \ + --runtime-env-json="${RUNTIME_ENV_JSON}" \ + -- python3 -m relax.entrypoints.train \ + --resource '{"sft":[1,0],"actor":[1,1]}' \ + --loss-type sft \ + --sft-objective reward_model \ + --prompt-data "${PROMPT_DATA}" \ + --eval-prompt-data task31 "${EVAL_PROMPT_DATA}" \ + --eval-interval "${EVAL_INTERVAL:-200}" \ + --input-key prompt \ + --preference-pair-id-key prompt_id \ + --preference-max-length 1024 \ + --preference-max-completion-length 512 \ + --preference-chat-template-sha256 56965952fc78cd889bcd1864d70e85271861eef93385410b879c0c4c2d40564d \ + --preference-require-no-generation-marker \ + --hf-checkpoint "${HF_CHECKPOINT}" \ + --ref-load "${HF_CHECKPOINT}" \ + --megatron-to-hf-mode bridge \ + --save "${SAVE_DIR}/${EXP_NAME}" \ + --load "${SAVE_DIR}/${EXP_NAME}" \ + --save-interval 50 \ + --num-rollout "${NUM_ROLLOUT:-200}" \ + --global-batch-size "${GLOBAL_BATCH_SIZE:-8}" \ + --use-dynamic-batch-size \ + --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ + --tensor-model-parallel-size 1 \ + --pipeline-model-parallel-size 1 \ + --context-parallel-size 1 \ + --optimizer adam \ + --lr "${LR:-1e-5}" \ + --lr-decay-style cosine \ + --min-lr 0 \ + --weight-decay 0.0 \ + --clip-grad 1.0 \ + --attention-dropout 0.0 \ + --hidden-dropout 0.0 \ + --attention-backend flash \ + --no-rope-fusion \ + --colocate \ + "${MODEL_ARGS[@]}" 2>&1 | tee "log/${EXP_NAME}-${now}.log" diff --git a/tests/backends/megatron/test_model_provider_vpp.py b/tests/backends/megatron/test_model_provider_vpp.py index 82c20510b..b4c65613b 100644 --- a/tests/backends/megatron/test_model_provider_vpp.py +++ b/tests/backends/megatron/test_model_provider_vpp.py @@ -211,6 +211,37 @@ def __init__(self): assert all("relax_hf_output_layer" not in name for name, _ in model.named_parameters()) +def test_bridge_reward_model_provider_registers_biasless_scalar_head_and_restores_on_error(monkeypatch): + class _FakeBridgeModel(torch.nn.Module): + def __init__(self): + super().__init__() + self.config = SimpleNamespace(hidden_size=4, sequence_parallel=False) + self.output_layer = torch.nn.Linear(4, 8) + + module, _ = _load_model_provider(monkeypatch, provider=_FakeProvider(_FakeBridgeModel())) + args = _bridge_args(loss_type="sft", sft_objective="reward_model") + model = module.get_model_provider_func(args, role="actor")(post_process=True) + reward_head = model.output_layer + parameter_ids = tuple(id(parameter) for parameter in reward_head.parameters()) + + assert isinstance(reward_head, ppo_utils.LinearForLastLayer) + assert tuple(reward_head.weight.shape) == (1, 4) + assert reward_head.bias is None + assert list(model.state_dict()) == ["output_layer.weight"] + + with pytest.raises(RuntimeError, match="bridge failed"): + with ppo_utils.use_critic_lm_head_for_hf_load([model]): + assert model.output_layer.out_features == 8 + raise RuntimeError("bridge failed") + + assert model.output_layer is reward_head + assert tuple(id(parameter) for parameter in reward_head.parameters()) == parameter_ids + assert not hasattr(model, ppo_utils._RELAX_HF_OUTPUT_LAYER_ATTR) + + reward_head.weight.main_grad = torch.zeros_like(reward_head.weight) + assert ppo_utils.validate_reward_model_head_registration([model], object()) == parameter_ids + + def test_hf_load_context_restores_same_value_head(monkeypatch): class _FakeBridgeModel(torch.nn.Module): def __init__(self): diff --git a/tests/backends/megatron/test_preference_batching.py b/tests/backends/megatron/test_preference_batching.py index 15c027b0b..44f3101dc 100644 --- a/tests/backends/megatron/test_preference_batching.py +++ b/tests/backends/megatron/test_preference_batching.py @@ -27,6 +27,8 @@ def _pair_rows(count=2): "rejected_loss_masks": [[0, 1]] * count, "chosen_total_lengths": [2] * count, "rejected_total_lengths": [2] * count, + "chosen_score_positions": [1] * count, + "rejected_score_positions": [1] * count, } diff --git a/tests/backends/megatron/test_sft_train_data_fields.py b/tests/backends/megatron/test_sft_train_data_fields.py index 79e00c2af..e44df2391 100644 --- a/tests/backends/megatron/test_sft_train_data_fields.py +++ b/tests/backends/megatron/test_sft_train_data_fields.py @@ -59,6 +59,8 @@ def test_preference_data_fields_keep_pairs_atomic(): "rejected_loss_masks", "chosen_total_lengths", "rejected_total_lengths", + "chosen_score_positions", + "rejected_score_positions", ] @@ -73,6 +75,8 @@ def test_preference_rows_expand_before_generic_rollout_post_processing(monkeypat "rejected_loss_masks": [[0, 1]], "chosen_total_lengths": [3], "rejected_total_lengths": [2], + "chosen_score_positions": [2], + "rejected_score_positions": [1], } args = Namespace(qkv_format="thd", is_vl_model=False, uses_unsplit_forward=False, use_opd=False) monkeypatch.setattr(stream_dataloader.device_utils, "make_current_torch_device", lambda: torch.device("cpu")) diff --git a/tests/engine/sft/dataset/test_preference.py b/tests/engine/sft/dataset/test_preference.py index d67aadbc0..42454a3f7 100644 --- a/tests/engine/sft/dataset/test_preference.py +++ b/tests/engine/sft/dataset/test_preference.py @@ -90,6 +90,8 @@ def test_explicit_pair_builds_identical_prompt_and_completion_only_masks(tmp_pat assert pair.rejected_loss_mask[: pair.rejected_prompt_length].sum().item() == 0 assert pair.chosen_loss_mask[pair.chosen_prompt_length :].all() assert pair.rejected_loss_mask[pair.rejected_prompt_length :].all() + assert pair.chosen_score_position == pair.chosen_total_length - 1 + assert pair.rejected_score_position == pair.rejected_total_length - 1 def test_implicit_ultrafeedback_pair_extracts_strict_common_prefix(tmp_path: Path): diff --git a/tests/engine/sft/eval/test_preference.py b/tests/engine/sft/eval/test_preference.py new file mode 100644 index 000000000..374fda08f --- /dev/null +++ b/tests/engine/sft/eval/test_preference.py @@ -0,0 +1,20 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +import pytest +import torch + +from relax.engine.sft.eval.preference import finalize_pair_metrics, pair_metric_sums + + +def test_pair_metric_sums_and_finalize_keep_ties_explicit(): + chosen = torch.tensor([2.0, 1.0, 1.0]) + rejected = torch.tensor([1.0, 2.0, 1.0]) + losses = torch.tensor([0.1, 0.2, 0.3]) + + metrics = finalize_pair_metrics(pair_metric_sums(chosen, rejected, losses), prefix="rm") + + assert metrics["eval/rm_loss"] == pytest.approx(0.2) + assert metrics["eval/rm_strict_accuracy"] == pytest.approx(1 / 3) + assert metrics["eval/rm_tie_rate"] == pytest.approx(1 / 3) + assert metrics["eval/rm_tie_aware_accuracy"] == pytest.approx(0.5) + assert metrics["eval/rm_pairs"] == 3 diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index 80d8f1941..89c379be2 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -32,8 +32,6 @@ def _args(**overrides) -> Namespace: "attention_dropout": 0.0, "sft_predict_interval": None, "eval_interval": None, - "eval_prompt_data": None, - "eval_size": None, "dpo_beta": 0.1, "rollout_temperature": 1.0, "dpo_reference_free": False, @@ -54,7 +52,6 @@ def test_preference_mode_is_nested_under_sft(): assert is_preference_mode(_args()) assert not is_preference_mode(_args(loss_type="policy_loss")) assert not is_preference_mode(_args(sft_objective="causal_lm")) - assert not is_preference_mode(_args(sft_objective="reward_model")) @pytest.mark.parametrize( @@ -76,7 +73,6 @@ def test_preference_mode_is_nested_under_sft(): ({"rollout_temperature": float("nan")}, "rollout-temperature 1.0"), ({"rollout_temperature": float("inf")}, "rollout-temperature 1.0"), ({"preference_max_completion_length": 2048}, "must not exceed"), - ({"eval_prompt_data": ["heldout", "eval.jsonl"]}, "follow-up reward-modeling PR"), ], ) def test_preference_validation_rejects_unsupported_configs(overrides: dict, match: str): @@ -91,3 +87,17 @@ def test_reference_free_dpo_does_not_require_ref_update_constraint(): def test_standard_dpo_requires_explicit_reference_repository_and_revision(): with pytest.raises(ValueError, match="dpo-reference-repository"): validate_preference_args(_args(dpo_reference_repository=None)) + + +def test_reward_model_accepts_hf_load_and_held_out_evaluation(): + validate_preference_args( + _args( + sft_objective="reward_model", + ref_load="/models/Qwen3-0.6B", + eval_prompt_data=["task31", "heldout.parquet"], + rollout_temperature=0.8, + enable_weights_backuper=False, + dpo_reference_repository=None, + dpo_reference_revision=None, + ) + ) diff --git a/tests/utils/training/test_preference_utils.py b/tests/utils/training/test_preference_utils.py index f1cf2d4a1..1456e8017 100644 --- a/tests/utils/training/test_preference_utils.py +++ b/tests/utils/training/test_preference_utils.py @@ -13,6 +13,8 @@ dpo_pair_loss, pack_preference_pair_indices, require_tensor_condition, + reward_model_pair_loss, + select_packed_sequence_scores, ) @@ -83,6 +85,39 @@ def test_dpo_pair_loss_rejects_missing_reference_and_non_finite_values(): dpo_pair_loss(torch.tensor([float("nan")]), finite, reference_free=True) +def test_reward_model_pair_loss_matches_independent_reference_and_gradient(): + chosen = torch.tensor([1.0, -1.0, 0.0], requires_grad=True) + rejected = torch.tensor([0.0, 2.0, 0.0], requires_grad=True) + + actual = reward_model_pair_loss(chosen, rejected) + expected = -F.logsigmoid(chosen - rejected) + assert torch.allclose(actual, expected, rtol=1e-6, atol=1e-6) + + actual.sum().backward() + actual_grad = chosen.grad.detach().clone() + chosen.grad = None + expected.sum().backward() + assert torch.allclose(actual_grad, chosen.grad, rtol=1e-6, atol=1e-6) + + +def test_select_packed_sequence_scores_preserves_pair_order_and_gradient(): + flat_logits = torch.arange(10, dtype=torch.float32, requires_grad=True) + logits = flat_logits.reshape(1, 10, 1) + + scores = select_packed_sequence_scores(logits, [3, 2, 4], [2, 1, 3]) + + assert scores.tolist() == [2.0, 4.0, 8.0] + scores.sum().backward() + expected = torch.zeros(10) + expected[[2, 4, 8]] = 1 + assert torch.equal(flat_logits.grad, expected) + + +def test_select_packed_sequence_scores_rejects_invalid_position(): + with pytest.raises(ValueError, match="outside"): + select_packed_sequence_scores(torch.zeros(1, 4, 1), [4], [4]) + + def test_pair_packer_is_deterministic_complete_and_capacity_safe(): costs = [2, 4, 4, 5, 5] pair_ids = ["a", "b", "c", "d", "e"] From 640700020976b1bddb1ed4628e52c9178685431c Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 02:00:36 +0800 Subject: [PATCH 14/25] fix(reward-model): enforce RFC contracts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Enforce reward-model runtime contracts - Avoid CUDA synchronization in the margin finite check - Validate terminal masks, tokens, packed segments, and pair identity - Restore step-zero and unconditional final preference evaluation ## Harden Megatron checkpoint resume - Persist and validate reward-model objective, role, and scalar-head metadata - Reject incompatible actor, SFT, critic, and partial-state resumes - Preserve restored optimizer, scheduler, RNG, and next-step behavior --- # ⭐ Feature ## Produce reproducible preference-evaluation evidence - Freeze the 512-pair probe and canonical batch-plan hashes - Write per-pair JSONL and PCG64 paired-bootstrap summaries - Align reward-model metrics and recipe batch size with RFC values --- # ✅ Tests ## Cover reward-model loss, checkpoint, and evaluation behavior - Add focused checkpoint and loss contract suites - Test bootstrap digests, artifacts, pair reordering, and eval scheduling --- # 📝 Documentation ## Document reward-model recipes and acceptance artifacts - Describe checkpoint compatibility and required evidence outputs --- docs/en/guide/dpo-training.md | 8 + docs/zh/guide/dpo-training.md | 8 + relax/backends/megatron/actor.py | 14 +- relax/backends/megatron/checkpoint.py | 96 +++++++- relax/backends/megatron/data.py | 1 + relax/backends/megatron/loss.py | 32 ++- relax/backends/megatron/model.py | 33 ++- relax/components/sft.py | 44 ++-- relax/engine/sft/dataset/preference.py | 6 +- relax/engine/sft/eval/acceptance.py | 183 +++++++++++++++ relax/engine/sft/eval/preference.py | 27 ++- relax/engine/sft/eval/runner.py | 82 ++++++- relax/engine/sft/runtime.py | 14 +- relax/utils/training/preference_utils.py | 83 ++++++- .../run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 2 +- .../megatron/test_reward_model_checkpoint.py | 208 ++++++++++++++++++ .../megatron/test_reward_model_loss.py | 94 ++++++++ .../megatron/test_sft_train_actor_eval.py | 35 +-- tests/engine/sft/eval/test_acceptance.py | 71 ++++++ tests/engine/sft/eval/test_preference.py | 14 +- tests/utils/training/test_preference_utils.py | 18 ++ 21 files changed, 1009 insertions(+), 64 deletions(-) create mode 100644 relax/engine/sft/eval/acceptance.py create mode 100644 tests/backends/megatron/test_reward_model_checkpoint.py create mode 100644 tests/backends/megatron/test_reward_model_loss.py create mode 100644 tests/engine/sft/eval/test_acceptance.py diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md index d3dacdf01..a3e9206c8 100644 --- a/docs/en/guide/dpo-training.md +++ b/docs/en/guide/dpo-training.md @@ -62,3 +62,11 @@ DPO emits the following training metrics under the `train/dpo/` namespace: - `strict_accuracy`, `tie_rate`, and `tie_aware_accuracy`. For distributed parity claims, run DP=1 and DP=2 with the same image, model/data revisions, hyperparameters, and batch semantics, and retain the raw logs and reference digests. + +## Reward modeling and acceptance artifacts + +The companion recipe is `scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh`. It defaults to 200 optimizer steps and 32 pairs per global batch. Preference evaluation runs before the first optimizer step (step 0), periodically, and after the final completed step even when the interval does not divide the run length. + +Both DPO and reward modeling write acceptance data under `//preference_eval/`: the canonical probe contract and SHA-256, the DP/micro-batch plan and SHA-256, step-0/final per-pair JSONL, and a 10,000-replicate FP64 PCG64 paired-bootstrap summary. Final evaluation fails if probe preprocessing, pair order, or the batch plan differs from step 0. Retain this directory together with the expanded command, environment inventory, raw stdout/stderr, metrics, and curves. + +Reward-model Megatron checkpoints persist `sft_objective=reward_model`, `head_type=reward_model_terminal_v1`, and `checkpoint_role=actor`. Resume rejects missing or incompatible metadata, non-exact scalar-head keys/shapes, partial optimizer/RNG restoration, and PPO critic checkpoints. diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md index 7608d97ad..777020212 100644 --- a/docs/zh/guide/dpo-training.md +++ b/docs/zh/guide/dpo-training.md @@ -62,3 +62,11 @@ DPO 在 `train/dpo/` 命名空间下记录以下训练指标： - `strict_accuracy`、`tie_rate` 和 `tie_aware_accuracy`。 如需声明分布式一致性，应在相同镜像、模型/数据 revision、超参数和 batch 语义下分别运行 DP=1、DP=2，并保留原始日志与 reference digest。 + +## Reward Modeling 与验收产物 + +配套 recipe 为 `scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh`，默认运行 200 个 optimizer step，global batch 为 32 pairs。偏好评测会在第一次 optimizer step 之前（step 0）、周期边界以及最终完成 step 后运行；最终评测不依赖 interval 恰好整除训练步数。 + +DPO 与 Reward Modeling 都会在 `//preference_eval/` 下写出验收数据：canonical probe 合同及 SHA-256、DP/micro-batch plan 及 SHA-256、step-0/final 逐 pair JSONL，以及 10,000 次 FP64 PCG64 paired-bootstrap summary。若 final 与 step 0 的预处理、pair 顺序或 batch plan 不一致，评测会立即失败。提交证据时需将该目录与展开后的命令、环境清单、原始 stdout/stderr、metrics 和曲线一并保留。 + +Reward Model 的 Megatron checkpoint 会持久化 `sft_objective=reward_model`、`head_type=reward_model_terminal_v1` 与 `checkpoint_role=actor`。resume 会拒绝缺失或不兼容的 metadata、非精确 scalar-head key/shape、只恢复部分 optimizer/RNG 状态，以及 PPO critic checkpoint。 diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index 459db7017..03819f931 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -771,10 +771,10 @@ def _run_step_evaluation(self, rollout_id: int, *, end_update_weight: bool = Fal should_run_predict = has_rollout and should_run_sft_predict(self.args, rollout_id) try: if should_run_eval: - if dist.get_rank() == 0: + if rollout_id > 0 and dist.get_rank() == 0: run( self.data_system_client.async_clear_partition( - partition_id=sft_partition_id(self.args, rollout_id) + partition_id=sft_partition_id(self.args, rollout_id - 1) ) ) dist.barrier(group=get_gloo_group()) @@ -807,6 +807,14 @@ def _request_rollout_evaluation(self, rollout_id: int, *, end_update_weight: boo self._run_step_evaluation(rollout_id, end_update_weight=end_update_weight) def train(self, rollout_id: int) -> None: + if ( + rollout_id == 0 + and is_preference_mode(self.args) + and not self.args.debug_train_only + and should_run_sft_eval(self.args, 0) + ): + self._run_step_evaluation(0) + if self.args.offload_rollout and dist.get_rank() == 0: pre_train_offload_handles = [] if self.genrm_manager is not None: @@ -1184,7 +1192,7 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: # RL-only generative eval (uses SGLang via rollout_manager.eval). SFT # uses local eval/predict runner below. dist.barrier(group=get_gloo_group()) - self._run_step_evaluation(rollout_id) + self._run_step_evaluation(rollout_id + 1 if is_sft_mode(self.args) else rollout_id) # On the final training step the rollout component has already exited # its main loop, so nothing else awaits the eval handler. Block here diff --git a/relax/backends/megatron/checkpoint.py b/relax/backends/megatron/checkpoint.py index 08e8b31b4..7f7811389 100644 --- a/relax/backends/megatron/checkpoint.py +++ b/relax/backends/megatron/checkpoint.py @@ -99,7 +99,100 @@ def _init_from_local_shards_and_global_metadata( # type: ignore[override] logger = get_logger(__name__) -__all__ = ["save_checkpoint"] +REWARD_MODEL_HEAD_TYPE = "reward_model_terminal_v1" + +__all__ = ["REWARD_MODEL_HEAD_TYPE", "load_checkpoint", "save_checkpoint", "scheduler_state_was_restored"] + + +def scheduler_state_was_restored(args, resumed_from_megatron: bool) -> bool: + return bool( + resumed_from_megatron + and not getattr(args, "no_load_optim", False) + and not getattr(args, "finetune", False) + and not getattr(args, "reset_optimizer_states", False) + ) + + +def _checkpoint_iteration_dir(load_path: str | Path) -> Path: + path = Path(load_path) + if re.fullmatch(r"iter_\d{7}", path.name): + return path + tracker = path / "latest_checkpointed_iteration.txt" + try: + iteration = int(tracker.read_text(encoding="utf-8").strip()) + except (OSError, ValueError) as exc: + raise RuntimeError(f"cannot resolve Megatron checkpoint iteration from {tracker}") from exc + return path / f"iter_{iteration:07d}" + + +def _metadata_value(metadata, name: str): + return metadata.get(name) if isinstance(metadata, dict) else getattr(metadata, name, None) + + +def _validate_reward_model_tensor_metadata(tensor_metadata: dict, hidden_size: int) -> None: + head_keys = [ + str(key) + for key in tensor_metadata + if not str(key).startswith("optimizer.") and ("output_layer." in str(key) or "reward_model_head." in str(key)) + ] + weight_keys = [key for key in head_keys if key.endswith("output_layer.weight")] + if len(weight_keys) != 1: + raise RuntimeError( + f"RM resume requires exactly one output_layer.weight checkpoint tensor, found {weight_keys}" + ) + unexpected = [key for key in head_keys if key != weight_keys[0]] + if unexpected: + raise RuntimeError(f"RM checkpoint contains unexpected scalar-head tensors: {unexpected}") + entry = tensor_metadata[weight_keys[0]] + shape = tuple(getattr(entry, "global_shape", getattr(entry, "shape", ()))) + expected = (1, int(hidden_size)) + if shape != expected: + raise RuntimeError(f"RM output_layer.weight shape mismatch: checkpoint={shape}, expected={expected}") + + +def _validate_checkpoint_contract(args, ddp_model, checkpoint_dir: Path) -> None: + from megatron.core import dist_checkpointing + + common = dist_checkpointing.load_common_state_dict(checkpoint_dir) + saved_args = common.get("args") + if saved_args is None: + raise RuntimeError(f"checkpoint {checkpoint_dir} is missing saved args metadata") + saved_objective = _metadata_value(saved_args, "sft_objective") + saved_head_type = _metadata_value(saved_args, "head_type") + saved_role = _metadata_value(saved_args, "checkpoint_role") + role = getattr(ddp_model[0], "role", "actor") + current_is_rm = ( + role == "actor" + and getattr(args, "loss_type", None) == "sft" + and getattr(args, "sft_objective", "causal_lm") == "reward_model" + ) + saved_is_rm = saved_objective == "reward_model" or saved_head_type == REWARD_MODEL_HEAD_TYPE + + if current_is_rm: + if (saved_objective, saved_head_type, saved_role) != ( + "reward_model", + REWARD_MODEL_HEAD_TYPE, + "actor", + ): + raise RuntimeError( + "RM resume requires checkpoint metadata " + "sft_objective=reward_model, head_type=reward_model_terminal_v1, checkpoint_role=actor; " + f"got objective={saved_objective!r}, head_type={saved_head_type!r}, role={saved_role!r}" + ) + incompatible_flags = [ + name + for name in ("no_load_optim", "no_load_rng", "finetune", "reset_optimizer_states") + if bool(getattr(args, name, False)) + ] + if incompatible_flags: + raise RuntimeError( + f"RM resume must restore optimizer, scheduler, and RNG state; incompatible flags: {incompatible_flags}" + ) + tensor_metadata = dist_checkpointing.load_tensors_metadata(str(checkpoint_dir)) + _validate_reward_model_tensor_metadata(tensor_metadata, int(args.hidden_size)) + elif saved_is_rm: + target = "PPO critic" if role == "critic" else "non-RM actor/SFT" + raise RuntimeError(f"{target} load rejects reward-model checkpoints") def load_checkpoint(ddp_model, optimizer, opt_param_scheduler, checkpointing_context, skip_load_to_model_and_opt): @@ -110,6 +203,7 @@ def load_checkpoint(ddp_model, optimizer, opt_param_scheduler, checkpointing_con exist = Path(load_path).exists() and _is_dir_nonempty(load_path) if exist and is_megatron_checkpoint(load_path): + _validate_checkpoint_contract(args, ddp_model, _checkpoint_iteration_dir(load_path)) try: return _load_checkpoint_megatron( ddp_model=ddp_model, diff --git a/relax/backends/megatron/data.py b/relax/backends/megatron/data.py index bef8e758a..fa312db45 100644 --- a/relax/backends/megatron/data.py +++ b/relax/backends/megatron/data.py @@ -451,6 +451,7 @@ def get_batch( from relax.utils.sft_utils import align_loss_mask_for_sft + batch["raw_loss_masks"] = list(batch["loss_masks"]) loss_masks: list[torch.Tensor] = [] per_sample_loss_masks: list[torch.Tensor] = [] full_per_sample_loss_masks: list[torch.Tensor] = [] diff --git a/relax/backends/megatron/loss.py b/relax/backends/megatron/loss.py index 9932f7d21..571fea03f 100644 --- a/relax/backends/megatron/loss.py +++ b/relax/backends/megatron/loss.py @@ -1301,19 +1301,37 @@ def reward_model_loss_function( score_positions = batch.get("score_positions") if score_positions is None: raise ValueError("reward-model batch is missing score_positions") - scores = select_packed_sequence_scores(logits, batch["total_lengths"], score_positions) - chosen_scores, rejected_scores = scores[0::2], scores[1::2] + scores = select_packed_sequence_scores( + logits, + batch["total_lengths"], + score_positions, + raw_loss_masks=batch.get("raw_loss_masks"), + packed_tokens=batch.get("tokens"), + branch_tokens=batch.get("unconcat_tokens"), + cu_seqlens=(batch["packed_seq_params"].cu_seqlens_q if batch.get("packed_seq_params") is not None else None), + ) + pair_ids = batch.get("preference_branch_pair_ids") + branch_is_chosen = batch.get("preference_is_chosen") + if pair_ids is None or branch_is_chosen is None: + raise ValueError("reward-model batch is missing preference pair identity fields") + chosen_indices, rejected_indices = build_preference_pair_indices(pair_ids, branch_is_chosen) + chosen_index = torch.as_tensor(chosen_indices, dtype=torch.long, device=logits.device) + rejected_index = torch.as_tensor(rejected_indices, dtype=torch.long, device=logits.device) + chosen_scores = scores.index_select(0, chosen_index) + rejected_scores = scores.index_select(0, rejected_index) pair_losses = reward_model_pair_loss(chosen_scores, rejected_scores) margins = chosen_scores - rejected_scores loss = pair_losses.sum() if pair_losses.numel() == 0: loss = loss + 0 * logits.sum() return loss, { - "loss": pair_losses.detach().sum(), - "rm_chosen_score": chosen_scores.detach().sum(), - "rm_rejected_score": rejected_scores.detach().sum(), - "rm_margin": margins.detach().sum(), - "rm_pair_accuracy": (margins > 0).to(torch.float32).detach().sum(), + "rm/loss": pair_losses.detach().sum(), + "rm/score_chosen_mean": chosen_scores.detach().sum(), + "rm/score_rejected_mean": rejected_scores.detach().sum(), + "rm/score_margin_mean": margins.detach().sum(), + "rm/accuracy": (margins > 0).to(torch.float32).detach().sum(), + "rm/_score_chosen_second_moment": chosen_scores.detach().square().sum(), + "rm/_score_rejected_second_moment": rejected_scores.detach().square().sum(), } diff --git a/relax/backends/megatron/model.py b/relax/backends/megatron/model.py index 6dec243c0..a2355d773 100644 --- a/relax/backends/megatron/model.py +++ b/relax/backends/megatron/model.py @@ -42,7 +42,13 @@ validate_reward_model_head_registration, ) -from .checkpoint import load_checkpoint, save_checkpoint +from .checkpoint import ( + REWARD_MODEL_HEAD_TYPE, + is_megatron_checkpoint, + load_checkpoint, + save_checkpoint, + scheduler_state_was_restored, +) from .data import DataIterator, get_batch from .loss import loss_function from .model_provider import get_model_provider_func, wrap_model_provider_with_freeze @@ -803,6 +809,12 @@ def forward_step( max_seq_lens=batch.get("max_seq_lens", None), padded_total_lengths=batch.get("padded_total_lengths", None), loss_masks=batch.get("loss_masks", None), + raw_loss_masks=batch.get("raw_loss_masks", None), + packed_tokens=batch.get("tokens", None), + branch_tokens=batch.get("unconcat_tokens", None), + cu_seqlens=( + batch["packed_seq_params"].cu_seqlens_q if batch.get("packed_seq_params") is not None else None + ), score_positions=batch.get("score_positions", None), dynamic_cp_size=batch.get("dynamic_cp_size", None), dynamic_cp_rank=batch.get("dynamic_cp_rank", None), @@ -1211,6 +1223,13 @@ def forward_step( # CP degree under dynamic CP (and is a no-op under static CP, where the # count previously carried the cancelling cp factor). loss_reduced[key] = value / num_samples_or_tokens + if "rm/_score_chosen_second_moment" in loss_reduced: + chosen_second = loss_reduced.pop("rm/_score_chosen_second_moment") + rejected_second = loss_reduced.pop("rm/_score_rejected_second_moment") + chosen_mean = loss_reduced["rm/score_chosen_mean"] + rejected_mean = loss_reduced["rm/score_rejected_mean"] + loss_reduced["rm/score_chosen_std"] = math.sqrt(max(chosen_second - chosen_mean**2, 0.0)) + loss_reduced["rm/score_rejected_std"] = math.sqrt(max(rejected_second - rejected_mean**2, 0.0)) return loss_reduced, grad_norm return {}, grad_norm @@ -1470,6 +1489,14 @@ def save( opt_param_scheduler (OptimizerParamScheduler): LR/WD scheduler. """ args = get_args() + role = getattr(model[0], "role", "actor") + args.checkpoint_role = role + if role == "actor" and is_preference_mode(args) and args.sft_objective == "reward_model": + args.head_type = REWARD_MODEL_HEAD_TYPE + elif role == "critic": + args.head_type = "critic_value_terminal_v1" + else: + args.head_type = "causal_lm_v1" if should_disable_forward_pre_hook(args): disable_forward_pre_hook(model) save_checkpoint( @@ -1588,6 +1615,7 @@ def initialize_model_and_optimizer( elif is_preference_mode(args) and args.sft_objective == "reward_model": reward_head_param_ids = validate_reward_model_head_registration(model, optimizer) clear_memory() + resumed_from_megatron = is_megatron_checkpoint(args.load) iteration, _ = load_checkpoint( model, optimizer, @@ -1609,7 +1637,8 @@ def initialize_model_and_optimizer( "reward-model head parameter identities changed during checkpoint loading" ) clear_memory() - if opt_param_scheduler is not None: + scheduler_was_restored = scheduler_state_was_restored(args, resumed_from_megatron) + if opt_param_scheduler is not None and not scheduler_was_restored: opt_param_scheduler.step(increment=iteration * args.global_batch_size) return model, optimizer, opt_param_scheduler, iteration diff --git a/relax/components/sft.py b/relax/components/sft.py index 1609dabe0..c3de24ab7 100644 --- a/relax/components/sft.py +++ b/relax/components/sft.py @@ -41,7 +41,7 @@ ) from relax.engine.sft.dataset.streaming import ProcessedSample, SFTStreamingDataset, pack_samples_for_tq from relax.engine.sft.debug_print import print_first_sample -from relax.engine.sft.runtime import is_preference_mode +from relax.engine.sft.runtime import is_preference_mode, should_run_sft_eval from relax.utils.data.processor_pool import ProcessorPool from relax.utils.misc import load_function from relax.utils.training.eval_config import build_named_prompt_data_configs @@ -399,7 +399,7 @@ async def _produce_one_step(self) -> None: self._logger.info( f"SFT step {self.step}: epoch boundary crossed (epoch={self._dataset.index_manager.current_epoch})" ) - await self._maybe_produce_eval() + await self._maybe_produce_eval(self.step + 1) self.step += 1 def _build_eval_batches(self) -> list[ProcessedSample] | None: @@ -414,8 +414,8 @@ def _build_eval_batches(self) -> list[ProcessedSample] | None: return self._eval_dataset.get_batch_in_order(0, len(self._eval_dataset)) return None - async def _maybe_produce_eval(self) -> None: - """Push the eval set under partitions ``sft_eval__n_`` when + async def _maybe_produce_eval(self, completed_steps: int) -> None: + """Push eval partitions keyed by completed optimizer-step count when due, chunked into ``global_batch_size`` pieces and serially drained. TQ per-partition storage is sized for ``global_batch_size`` (one train @@ -425,10 +425,7 @@ async def _maybe_produce_eval(self) -> None: discover it, and push-then-wait-for-drain serially. Eval blocks the producer here, but only on eval steps. """ - eval_interval = getattr(self.config, "eval_interval", None) - if not eval_interval or eval_interval <= 0: - return - if (self.step + 1) % eval_interval != 0: + if not should_run_sft_eval(self.config, completed_steps): return samples = self._build_eval_batches() if samples is None: @@ -436,6 +433,16 @@ async def _maybe_produce_eval(self) -> None: if not samples: self._logger.warning("Eval source produced 0 valid samples; skipping eval push.") return + if is_preference_mode(self.config): + from relax.engine.sft.eval.acceptance import record_probe_contract + + samples = sorted(samples, key=lambda pair: pair.pair_id) + record_probe_contract( + getattr(self.config, "save", None), + self.config.sft_objective, + completed_steps, + samples, + ) # Pad sub-gbs eval pools with random resamples so the eval set always # forms at least one full ``global_batch_size`` chunk. Without this the @@ -446,11 +453,11 @@ async def _maybe_produce_eval(self) -> None: gbs = self.config.global_batch_size n_original = len(samples) if n_original < gbs: - rng = random.Random(self.step) + rng = random.Random(completed_steps) pad_count = gbs - n_original samples = list(samples) + rng.choices(samples, k=pad_count) self._logger.warning( - f"Eval @ step {self.step}: eval pool of {n_original} samples is smaller than " + f"Eval @ completed_steps={completed_steps}: eval pool of {n_original} samples is smaller than " f"global_batch_size ({gbs}); random-padded with {pad_count} resampled (with " f"replacement) samples to fill one batch. PPL counts duplicated samples — " f"interpret with caution." @@ -469,7 +476,8 @@ async def _maybe_produce_eval(self) -> None: # Drain the current train partition so the eval chunks have the full # TQ capacity to themselves. - await self._wait_for_partition_drained(f"sft_{self.step}") + if completed_steps > 0: + await self._wait_for_partition_drained(f"sft_{completed_steps - 1}") chunk_size = self.config.global_batch_size # Drop trailing samples that don't fill a full chunk. The consumer's @@ -483,13 +491,13 @@ async def _maybe_produce_eval(self) -> None: n_dropped = n_samples - n_chunks * chunk_size if n_chunks == 0: self._logger.warning( - f"Eval @ step {self.step}: eval pool of {n_samples} samples is smaller than " + f"Eval @ completed_steps={completed_steps}: eval pool of {n_samples} samples is smaller than " f"global_batch_size ({chunk_size}); cannot push any chunk, skipping eval." ) return if n_dropped > 0: self._logger.warning( - f"Eval @ step {self.step}: dropping {n_dropped} trailing sample(s) so eval " + f"Eval @ completed_steps={completed_steps}: dropping {n_dropped} trailing sample(s) so eval " f"chunks align to global_batch_size ({chunk_size}); raise eval pool size or " f"reduce global_batch_size if this matters." ) @@ -499,13 +507,14 @@ async def _maybe_produce_eval(self) -> None: # step. On timeout we clear our own pending chunk and bail. chunk_drain_timeout = float(getattr(self.config, "sft_eval_chunk_drain_timeout_sec", 600.0)) self._logger.info( - f"Eval @ step {self.step}: pushing {n_chunks * chunk_size} samples in {n_chunks} chunk(s) of {chunk_size}." + f"Eval @ completed_steps={completed_steps}: pushing {n_chunks * chunk_size} samples " + f"in {n_chunks} chunk(s) of {chunk_size}." ) for chunk_idx in range(n_chunks): s = chunk_idx * chunk_size e = s + chunk_size chunk = {k: v[s:e] for k, v in backend_batch.items()} - partition_id = f"sft_eval_{self.step}_n{n_chunks}_{chunk_idx}" + partition_id = f"sft_eval_{completed_steps}_n{n_chunks}_{chunk_idx}" await self.data_system_client.async_put( data=dict_to_tensordict(chunk, batch_size=len(chunk[row_key])), partition_id=partition_id, @@ -514,7 +523,8 @@ async def _maybe_produce_eval(self) -> None: drained = await self._wait_for_partition_drained(partition_id, timeout_sec=chunk_drain_timeout) if not drained: self._logger.warning( - f"Eval @ step {self.step}: chunk {chunk_idx}/{n_chunks} ({partition_id}) did not drain " + f"Eval @ completed_steps={completed_steps}: chunk {chunk_idx}/{n_chunks} " + f"({partition_id}) did not drain " f"within {chunk_drain_timeout}s; aborting eval push and clearing TQ." ) await self.data_system_client.async_clear_partition(partition_id=partition_id) @@ -528,6 +538,8 @@ async def run(self) -> None: async def _async_run(self) -> None: try: + if self.step == 0 and is_preference_mode(self.config): + await self._maybe_produce_eval(0) for _ in range(self.config.num_rollout): if self._stop_event.is_set(): break diff --git a/relax/engine/sft/dataset/preference.py b/relax/engine/sft/dataset/preference.py index a68eec2fe..886db4cbc 100644 --- a/relax/engine/sft/dataset/preference.py +++ b/relax/engine/sft/dataset/preference.py @@ -509,9 +509,9 @@ def pack_preference_pairs_for_tq( """Pack atomic pair rows and matching TransferQueue length metadata.""" if not pairs: raise ValueError("preference pair batch must not be empty") - encoded_pair_ids = [ - int.from_bytes(hashlib.sha256(pair.pair_id.encode()).digest()[:8], "big") >> 1 for pair in pairs - ] + from relax.engine.sft.eval.acceptance import encoded_pair_id + + encoded_pair_ids = [encoded_pair_id(pair.pair_id) for pair in pairs] if len(set(encoded_pair_ids)) != len(encoded_pair_ids): raise ValueError("preference pair ID hash collision within batch") batch: dict[str, list[Any]] = { diff --git a/relax/engine/sft/eval/acceptance.py b/relax/engine/sft/eval/acceptance.py new file mode 100644 index 000000000..fde34a2aa --- /dev/null +++ b/relax/engine/sft/eval/acceptance.py @@ -0,0 +1,183 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Reproducible preference-evaluation artifacts and RFC statistics.""" + +import hashlib +import json +from pathlib import Path +from typing import Any, Sequence + + +PREFERENCE_PROBE_PAIR_COUNT = 512 + + +def encoded_pair_id(pair_id: str) -> int: + return int.from_bytes(hashlib.sha256(pair_id.encode()).digest()[:8], "big") >> 1 + + +def canonical_sha256(value: Any) -> str: + payload = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode() + return hashlib.sha256(payload).hexdigest() + + +def paired_bootstrap(values: Sequence[float], *, seed: int = 1234, num_replicates: int = 10_000) -> dict[str, Any]: + """Compute the RFC's one-sided percentile bootstrap without dtype drift.""" + import numpy as np + + array = np.asarray(values, dtype=np.float64) + if array.ndim != 1 or array.size == 0: + raise ValueError("paired bootstrap requires a non-empty one-dimensional vector") + rng = np.random.Generator(np.random.PCG64(seed)) + indices = rng.integers(0, array.size, size=(num_replicates, array.size), endpoint=False) + replicates = array[indices].mean(axis=1) + if replicates.dtype != np.float64: + raise RuntimeError(f"bootstrap replicates must remain float64, got {replicates.dtype}") + lower_95 = np.quantile(replicates, 0.05, method="linear") + return { + "numpy_version": np.__version__, + "seed": seed, + "num_replicates": num_replicates, + "point_estimate": float(array.mean()), + "lower_95": float(lower_95), + "passes_lower_bound_gt_0_50": bool(lower_95 > 0.50), + "indices_sha256": hashlib.sha256(indices.astype(" Path | None: + return None if not save_path else Path(save_path) / "preference_eval" + + +def _atomic_write_json(path: Path, value: Any) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8") + temporary.replace(path) + + +def record_probe_contract( + save_path: str | None, + objective: str, + completed_steps: int, + pairs, + *, + expected_pair_count: int = PREFERENCE_PROBE_PAIR_COUNT, +) -> dict[str, Any] | None: + directory = artifact_directory(save_path) + if directory is None: + return None + rows = [ + { + "pair_id": pair.pair_id, + "encoded_pair_id": encoded_pair_id(pair.pair_id), + "chosen_tokens": pair.chosen_tokens.tolist(), + "rejected_tokens": pair.rejected_tokens.tolist(), + "chosen_raw_loss_mask": pair.chosen_loss_mask.tolist(), + "rejected_raw_loss_mask": pair.rejected_loss_mask.tolist(), + "chosen_score_position": pair.chosen_score_position, + "rejected_score_position": pair.rejected_score_position, + } + for pair in pairs + ] + if len(rows) != expected_pair_count: + raise RuntimeError(f"preference eval requires exactly {expected_pair_count} probe pairs, got {len(rows)}") + contract = { + "objective": objective, + "pair_count": len(rows), + "pair_ids": [row["pair_id"] for row in rows], + "encoded_pair_id_map": {str(row["encoded_pair_id"]): row["pair_id"] for row in rows}, + "probe_sha256": canonical_sha256(rows), + } + baseline_path = directory / f"{objective}-probe-contract.json" + if completed_steps == 0: + _atomic_write_json(baseline_path, contract) + else: + if not baseline_path.is_file(): + raise RuntimeError(f"preference final eval is missing step-0 probe contract: {baseline_path}") + baseline = json.loads(baseline_path.read_text(encoding="utf-8")) + if contract != baseline: + raise RuntimeError( + "preference probe preprocessing/order changed between step 0 and final eval: " + f"baseline={baseline.get('probe_sha256')}, current={contract['probe_sha256']}" + ) + return contract + + +def write_pair_artifacts( + save_path: str | None, + objective: str, + completed_steps: int, + encoded_rows: list[dict[str, Any]], + batch_plan: list[dict[str, Any]], +) -> dict[str, Any] | None: + directory = artifact_directory(save_path) + if directory is None: + return None + contract_path = directory / f"{objective}-probe-contract.json" + if not contract_path.is_file(): + raise RuntimeError(f"preference eval is missing probe contract: {contract_path}") + contract = json.loads(contract_path.read_text(encoding="utf-8")) + pair_id_map = contract["encoded_pair_id_map"] + rows = [] + for row in encoded_rows: + row = dict(row) + encoded = str(row.pop("encoded_pair_id")) + if encoded not in pair_id_map: + raise RuntimeError(f"preference eval produced unknown encoded pair id {encoded}") + row["pair_id"] = pair_id_map[encoded] + rows.append(row) + rows.sort(key=lambda row: contract["pair_ids"].index(row["pair_id"])) + if len(rows) != contract["pair_count"] or len({row["pair_id"] for row in rows}) != len(rows): + raise RuntimeError( + "preference eval pair artifact is incomplete or duplicated: " + f"expected={contract['pair_count']}, actual={len(rows)}" + ) + + plan_sha256 = canonical_sha256(batch_plan) + baseline_summary_path = directory / f"{objective}-step-0000000-summary.json" + if completed_steps != 0: + if not baseline_summary_path.is_file(): + raise RuntimeError("final preference eval is missing step-0 batch-plan evidence") + baseline = json.loads(baseline_summary_path.read_text(encoding="utf-8")) + if plan_sha256 != baseline["batch_plan_sha256"]: + raise RuntimeError( + "preference eval batch plan changed between step 0 and final: " + f"baseline={baseline['batch_plan_sha256']}, current={plan_sha256}" + ) + + if objective == "reward_model": + accuracy_values = [float(row["chosen_score"] > row["rejected_score"]) for row in rows] + else: + epsilon = 1e-6 + accuracy_values = [ + 1.0 if row["reward_margin"] > epsilon else 0.0 if row["reward_margin"] < -epsilon else 0.5 for row in rows + ] + summary = { + "objective": objective, + "completed_steps": completed_steps, + "pair_count": len(rows), + "probe_sha256": contract["probe_sha256"], + "batch_plan_sha256": plan_sha256, + "bootstrap": paired_bootstrap(accuracy_values), + } + stem = f"{objective}-step-{completed_steps:07d}" + rows_path = directory / f"{stem}-pairs.jsonl" + rows_path.parent.mkdir(parents=True, exist_ok=True) + rows_path.write_text( + "".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), + encoding="utf-8", + ) + _atomic_write_json(directory / f"{stem}-batch-plan.json", batch_plan) + _atomic_write_json(directory / f"{stem}-summary.json", summary) + return summary + + +__all__ = [ + "PREFERENCE_PROBE_PAIR_COUNT", + "canonical_sha256", + "encoded_pair_id", + "paired_bootstrap", + "record_probe_contract", + "write_pair_artifacts", +] diff --git a/relax/engine/sft/eval/preference.py b/relax/engine/sft/eval/preference.py index 0aae061c8..1fd19b1f7 100644 --- a/relax/engine/sft/eval/preference.py +++ b/relax/engine/sft/eval/preference.py @@ -12,20 +12,39 @@ def compute_reward_model_eval_step( *, total_lengths, score_positions=None, + raw_loss_masks=None, + packed_tokens=None, + branch_tokens=None, + cu_seqlens=None, **_, ) -> tuple[torch.Tensor, dict[str, list[torch.Tensor]]]: if score_positions is None: raise ValueError("reward-model eval batch is missing score_positions") - scores = select_packed_sequence_scores(logits, total_lengths, score_positions).detach() - return torch.empty((0,), device=logits.device), {"scores": [scores]} + scores = select_packed_sequence_scores( + logits, + total_lengths, + score_positions, + raw_loss_masks=raw_loss_masks, + packed_tokens=packed_tokens, + branch_tokens=branch_tokens, + cu_seqlens=cu_seqlens, + ).detach() + # Emit one scalar per branch so ``forward_only`` can restore original + # sample order after dynamic micro-batch length balancing. + return torch.empty((0,), device=logits.device), {"scores": list(scores.unbind())} -def pair_metric_sums(chosen: torch.Tensor, rejected: torch.Tensor, losses: torch.Tensor) -> torch.Tensor: +def pair_metric_sums( + chosen: torch.Tensor, + rejected: torch.Tensor, + losses: torch.Tensor, + *, + epsilon: float = 1e-6, +) -> torch.Tensor: """Return additive loss/count/score/margin/correct/tie statistics.""" if chosen.shape != rejected.shape or chosen.shape != losses.shape: raise ValueError("preference eval tensors must have identical shapes") margin = chosen - rejected - epsilon = 1e-6 correct = (margin > epsilon).to(torch.float64).sum() ties = (margin.abs() <= epsilon).to(torch.float64).sum() return torch.stack( diff --git a/relax/engine/sft/eval/runner.py b/relax/engine/sft/eval/runner.py index f943a3695..9d6640504 100644 --- a/relax/engine/sft/eval/runner.py +++ b/relax/engine/sft/eval/runner.py @@ -218,6 +218,8 @@ def _run_preference_eval(actor, rollout_id: int) -> None: ] n_chunks = _wait_for_eval_chunk_count(actor, rollout_id) local = torch.zeros(7, device=device_utils.make_current_torch_device(), dtype=torch.float64) + local_rows: list[dict] = [] + local_plan: list[dict] = [] started = time.monotonic() with timer("preference_eval"): for chunk_idx in range(n_chunks): @@ -233,6 +235,22 @@ def _run_preference_eval(actor, rollout_id: int) -> None: batch_index += 1 rollout_data = expand_preference_rollout_data(pair_rows) data_iterator, num_microbatches = get_data_iterator(args, actor.model, rollout_data) + for microbatch_index, branch_indices in enumerate(data_iterator[0].micro_batch_indices): + encoded_ids = [] + for branch_index in branch_indices: + pair_id = int(rollout_data["preference_branch_pair_ids"][branch_index]) + if not encoded_ids or encoded_ids[-1] != pair_id: + encoded_ids.append(pair_id) + local_plan.append( + { + "rank": dist.get_rank(), + "chunk": chunk_idx, + "batch": batch_index - 1, + "microbatch": microbatch_index, + "encoded_pair_ids": encoded_ids, + } + ) + encoded_pair_ids = [int(value) for value in pair_rows["pair_ids"]] if args.sft_objective == "dpo": if args.dpo_reference_free: reference_sums = None @@ -263,6 +281,36 @@ def _run_preference_eval(actor, rollout_id: int) -> None: reference_free=args.dpo_reference_free, ) local += pair_metric_sums(chosen_values, rejected_values, losses) + policy_chosen_values = policy_chosen.detach().cpu().tolist() + policy_rejected_values = policy_rejected.detach().cpu().tolist() + reference_chosen_values = ( + [0.0] * len(encoded_pair_ids) + if reference_chosen is None + else reference_chosen.detach().cpu().tolist() + ) + reference_rejected_values = ( + [0.0] * len(encoded_pair_ids) + if reference_rejected is None + else reference_rejected.detach().cpu().tolist() + ) + chosen_reward_values = chosen_values.detach().cpu().tolist() + rejected_reward_values = rejected_values.detach().cpu().tolist() + loss_values = losses.detach().cpu().tolist() + for index, encoded_pair_id in enumerate(encoded_pair_ids): + margin = chosen_reward_values[index] - rejected_reward_values[index] + local_rows.append( + { + "encoded_pair_id": encoded_pair_id, + "policy_chosen_logp": policy_chosen_values[index], + "policy_rejected_logp": policy_rejected_values[index], + "reference_chosen_logp": reference_chosen_values[index], + "reference_rejected_logp": reference_rejected_values[index], + "chosen_implicit_reward": chosen_reward_values[index], + "rejected_implicit_reward": rejected_reward_values[index], + "reward_margin": margin, + "pair_loss": loss_values[index], + } + ) else: outputs = forward_only( compute_reward_model_eval_step, @@ -273,10 +321,22 @@ def _run_preference_eval(actor, rollout_id: int) -> None: store_prefix="", ) if mpu.is_pipeline_last_stage(): - scores = torch.cat(outputs["scores"]).to(local.device) + scores = torch.stack(outputs["scores"]).to(local.device) chosen_scores, rejected_scores = scores[0::2], scores[1::2] losses = reward_model_pair_loss(chosen_scores, rejected_scores) - local += pair_metric_sums(chosen_scores, rejected_scores, losses) + local += pair_metric_sums(chosen_scores, rejected_scores, losses, epsilon=0.0) + chosen_values = chosen_scores.detach().cpu().tolist() + rejected_values = rejected_scores.detach().cpu().tolist() + loss_values = losses.detach().cpu().tolist() + for index, encoded_pair_id in enumerate(encoded_pair_ids): + local_rows.append( + { + "encoded_pair_id": encoded_pair_id, + "chosen_score": chosen_values[index], + "rejected_score": rejected_values[index], + "pair_loss": loss_values[index], + } + ) dist.barrier(group=get_gloo_group()) if dist.get_rank() == 0: run(actor.data_system_client.async_clear_partition(partition_id=partition_id)) @@ -285,7 +345,25 @@ def _run_preference_eval(actor, rollout_id: int) -> None: dist.all_reduce(local, op=dist.ReduceOp.SUM, group=mpu.get_data_parallel_group(with_context_parallel=True)) metrics = finalize_pair_metrics(local, prefix="dpo" if args.sft_objective == "dpo" else "rm") metrics["perf/preference_eval_time"] = time.monotonic() - started + gloo_group = get_gloo_group() + gathered_rows = [None] * dist.get_world_size(group=gloo_group) + gathered_plans = [None] * dist.get_world_size(group=gloo_group) + dist.all_gather_object(gathered_rows, local_rows, group=gloo_group) + dist.all_gather_object(gathered_plans, local_plan, group=gloo_group) if is_megatron_main_rank(): + from relax.engine.sft.eval.acceptance import write_pair_artifacts + + summary = write_pair_artifacts( + getattr(args, "save", None), + args.sft_objective, + rollout_id, + [row for rank_rows in gathered_rows for row in rank_rows], + [entry for rank_plan in gathered_plans for entry in rank_plan], + ) + if summary is not None: + metrics[f"eval/{'dpo' if args.sft_objective == 'dpo' else 'rm'}_bootstrap_lower_95"] = summary[ + "bootstrap" + ]["lower_95"] step = compute_rollout_step(args, rollout_id) metrics["rollout/step"] = step tracking_utils.log(args, metrics, step_key="rollout/step") diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 668231168..cd3376c98 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -124,8 +124,14 @@ def sft_task_name(args: Namespace, *, component: str = "actor") -> str: return "train" -def should_run_sft_eval(args: Namespace, rollout_id: int) -> bool: - """SFT PPL eval triggers every ``--eval-interval`` steps under SFT mode +def should_run_sft_eval(args: Namespace, completed_steps: int) -> bool: + """Return whether eval is due after ``completed_steps`` optimizer steps. + + Preference objectives additionally evaluate at the true pre-training + baseline (0) and at the final completed step, independent of whether the + periodic interval happens to divide the run length. + + SFT PPL eval triggers every ``--eval-interval`` steps under SFT mode when an eval source is configured (either ``--eval-prompt-data`` or ``--eval-size``, mutually exclusive — see ``utils/arguments.py``). @@ -139,7 +145,9 @@ def should_run_sft_eval(args: Namespace, rollout_id: int) -> bool: interval = getattr(args, "eval_interval", None) if interval is None or interval <= 0: return False - return (rollout_id + 1) % interval == 0 + if is_preference_mode(args) and completed_steps in {0, int(getattr(args, "num_rollout", 0) or 0)}: + return True + return completed_steps > 0 and completed_steps % interval == 0 def should_run_sft_predict(args: Namespace, rollout_id: int) -> bool: diff --git a/relax/utils/training/preference_utils.py b/relax/utils/training/preference_utils.py index 615049a11..47a86a5ce 100644 --- a/relax/utils/training/preference_utils.py +++ b/relax/utils/training/preference_utils.py @@ -112,8 +112,10 @@ def reward_model_pair_loss(chosen_scores: torch.Tensor, rejected_scores: torch.T """Return unreduced Bradley-Terry loss, one value per preference pair.""" _validate_same_shape("reward-model scores", chosen_scores, rejected_scores) margins = chosen_scores - rejected_scores - if not torch.isfinite(margins).all(): - raise ValueError("reward-model margins must contain only finite values") + require_tensor_condition( + torch.isfinite(margins).all(), + "reward-model margins must contain only finite values", + ) return -F.logsigmoid(margins) @@ -121,8 +123,13 @@ def select_packed_sequence_scores( logits: torch.Tensor, total_lengths: Sequence[int], score_positions: Sequence[int], + *, + raw_loss_masks: Sequence[torch.Tensor] | None = None, + packed_tokens: torch.Tensor | None = None, + branch_tokens: Sequence[torch.Tensor] | None = None, + cu_seqlens: torch.Tensor | None = None, ) -> torch.Tensor: - """Select one scalar score per sequence from a CP=1 THD packed output.""" + """Validate and select one terminal score per CP=1 THD branch.""" if len(total_lengths) != len(score_positions): raise ValueError( f"total_lengths/score_positions length mismatch: {len(total_lengths)} vs {len(score_positions)}" @@ -136,6 +143,31 @@ def select_packed_sequence_scores( else: raise ValueError(f"reward-model logits must have shape [1,T,1], [T,1], or [T], got {tuple(logits.shape)}") + branch_count = len(total_lengths) + optional_fields = { + "raw_loss_masks": raw_loss_masks, + "branch_tokens": branch_tokens, + } + for name, values in optional_fields.items(): + if values is not None and len(values) != branch_count: + raise ValueError(f"{name} must be branch aligned: expected {branch_count}, got {len(values)}") + if (packed_tokens is None) != (branch_tokens is None): + raise ValueError("packed_tokens and branch_tokens must be provided together") + + if packed_tokens is not None: + if packed_tokens.ndim == 2 and packed_tokens.shape[0] == 1: + flat_packed_tokens = packed_tokens[0] + elif packed_tokens.ndim == 1: + flat_packed_tokens = packed_tokens + else: + raise ValueError(f"packed reward tokens must have shape [1,T] or [T], got {tuple(packed_tokens.shape)}") + if flat_packed_tokens.numel() != flat_logits.numel(): + raise ValueError( + f"packed reward token/logit length mismatch: {flat_packed_tokens.numel()} vs {flat_logits.numel()}" + ) + else: + flat_packed_tokens = None + offsets: list[int] = [] cursor = 0 for index, (length, position) in enumerate(zip(total_lengths, score_positions, strict=True)): @@ -145,10 +177,53 @@ def select_packed_sequence_scores( raise ValueError(f"sequence {index} has non-positive total length {length}") if not 0 <= position < length: raise ValueError(f"sequence {index} score position {position} is outside [0, {length})") - offsets.append(cursor + position) + packed_index = cursor + position + offsets.append(packed_index) + if raw_loss_masks is not None: + raw_mask = torch.as_tensor(raw_loss_masks[index]) + if raw_mask.ndim != 1 or raw_mask.numel() != length: + raise ValueError( + f"sequence {index} raw loss mask must have length {length}, got {tuple(raw_mask.shape)}" + ) + require_tensor_condition( + raw_mask[position] == 1, + f"sequence {index} score position must be supervised by raw_loss_mask", + ) + if flat_packed_tokens is not None and branch_tokens is not None: + branch = torch.as_tensor(branch_tokens[index], device=flat_packed_tokens.device) + if branch.ndim != 1 or branch.numel() != length: + raise ValueError( + f"sequence {index} branch tokens must have length {length}, got {tuple(branch.shape)}" + ) + require_tensor_condition( + flat_packed_tokens[packed_index] == branch[position], + f"sequence {index} packed terminal token does not match branch terminal token", + ) cursor += length if cursor > flat_logits.numel(): raise ValueError(f"packed reward logits contain {flat_logits.numel()} tokens, expected at least {cursor}") + if cu_seqlens is not None: + if cu_seqlens.ndim != 1 or cu_seqlens.numel() not in {branch_count + 1, branch_count + 2}: + raise ValueError( + "reward-model cu_seqlens must describe the real branches and at most one trailing padding segment" + ) + expected = torch.tensor( + [0, *torch.tensor(total_lengths, dtype=torch.long).cumsum(0).tolist()], + device=cu_seqlens.device, + dtype=cu_seqlens.dtype, + ) + require_tensor_condition( + (cu_seqlens[: branch_count + 1] == expected).all(), + "reward-model cu_seqlens do not match branch lengths/order", + ) + if cu_seqlens.numel() == branch_count + 1: + if flat_logits.numel() != cursor: + raise ValueError("reward-model packed tail must be represented by an explicit padding segment") + else: + require_tensor_condition( + cu_seqlens[-1] == flat_logits.numel(), + "reward-model padding segment must cover only the packed tail", + ) if not offsets: return flat_logits.new_empty((0,)) return flat_logits[torch.tensor(offsets, device=flat_logits.device, dtype=torch.long)] diff --git a/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index cbfa10916..d2bef6f23 100644 --- a/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -43,7 +43,7 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --load "${SAVE_DIR}/${EXP_NAME}" \ --save-interval 50 \ --num-rollout "${NUM_ROLLOUT:-200}" \ - --global-batch-size "${GLOBAL_BATCH_SIZE:-8}" \ + --global-batch-size "${GLOBAL_BATCH_SIZE:-32}" \ --use-dynamic-batch-size \ --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ --tensor-model-parallel-size 1 \ diff --git a/tests/backends/megatron/test_reward_model_checkpoint.py b/tests/backends/megatron/test_reward_model_checkpoint.py new file mode 100644 index 000000000..e55940726 --- /dev/null +++ b/tests/backends/megatron/test_reward_model_checkpoint.py @@ -0,0 +1,208 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Reward-model checkpoint metadata and exact head-schema tests.""" + +import copy +from types import SimpleNamespace + +import pytest +import torch + + +try: + from relax.backends.megatron import checkpoint as checkpoint_module +except Exception as exc: + pytest.skip(f"Megatron checkpoint helpers unavailable: {exc}", allow_module_level=True) + + +class _TensorMetadata: + def __init__(self, shape): + self.global_shape = shape + + +def test_reward_model_tensor_metadata_accepts_exact_bias_free_head(): + checkpoint_module._validate_reward_model_tensor_metadata( + { + "model.output_layer.weight": _TensorMetadata((1, 1024)), + "model.decoder.weight": _TensorMetadata((8, 8)), + "optimizer.state.exp_avg.model.output_layer.weight": _TensorMetadata((1, 1024)), + "optimizer.state.exp_avg_sq.model.output_layer.weight": _TensorMetadata((1, 1024)), + }, + 1024, + ) + + +@pytest.mark.parametrize( + ("metadata", "match"), + [ + ({}, "exactly one"), + ({"model.output_layer.weight": _TensorMetadata((2, 1024))}, "shape mismatch"), + ( + { + "model.output_layer.weight": _TensorMetadata((1, 1024)), + "model.output_layer.bias": _TensorMetadata((1,)), + }, + "unexpected", + ), + ( + { + "model.output_layer.weight": _TensorMetadata((1, 1024)), + "model.reward_model_head.weight": _TensorMetadata((1, 1024)), + }, + "unexpected", + ), + ], +) +def test_reward_model_tensor_metadata_rejects_missing_extra_and_wrong_shape(metadata, match): + with pytest.raises(RuntimeError, match=match): + checkpoint_module._validate_reward_model_tensor_metadata(metadata, 1024) + + +def test_reward_model_contract_rejects_critic_metadata_before_tensor_load(monkeypatch, tmp_path): + calls = [] + fake_dist_checkpointing = SimpleNamespace( + load_common_state_dict=lambda path: { + "args": SimpleNamespace( + sft_objective="causal_lm", head_type="critic_value_terminal_v1", checkpoint_role="critic" + ) + }, + load_tensors_metadata=lambda path: calls.append(path), + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + args = SimpleNamespace( + loss_type="sft", + sft_objective="reward_model", + hidden_size=1024, + no_load_optim=False, + no_load_rng=False, + finetune=False, + reset_optimizer_states=False, + ) + model = [SimpleNamespace(role="actor")] + with pytest.raises(RuntimeError, match="RM resume requires checkpoint metadata"): + checkpoint_module._validate_checkpoint_contract(args, model, tmp_path) + assert calls == [] + + +def test_reward_model_contract_accepts_complete_metadata_and_exact_head(monkeypatch, tmp_path): + fake_dist_checkpointing = SimpleNamespace( + load_common_state_dict=lambda path: { + "args": SimpleNamespace( + sft_objective="reward_model", + head_type="reward_model_terminal_v1", + checkpoint_role="actor", + ) + }, + load_tensors_metadata=lambda path: {"model.output_layer.weight": _TensorMetadata((1, 1024))}, + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + args = SimpleNamespace( + loss_type="sft", + sft_objective="reward_model", + hidden_size=1024, + no_load_optim=False, + no_load_rng=False, + finetune=False, + reset_optimizer_states=False, + ) + checkpoint_module._validate_checkpoint_contract(args, [SimpleNamespace(role="actor")], tmp_path) + + +@pytest.mark.parametrize("flag", ["no_load_optim", "no_load_rng", "finetune", "reset_optimizer_states"]) +def test_reward_model_contract_rejects_partial_resume_flags(monkeypatch, tmp_path, flag): + fake_dist_checkpointing = SimpleNamespace( + load_common_state_dict=lambda path: { + "args": SimpleNamespace( + sft_objective="reward_model", + head_type="reward_model_terminal_v1", + checkpoint_role="actor", + ) + }, + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + values = dict(no_load_optim=False, no_load_rng=False, finetune=False, reset_optimizer_states=False) + values[flag] = True + args = SimpleNamespace(loss_type="sft", sft_objective="reward_model", hidden_size=1024, **values) + with pytest.raises(RuntimeError, match="must restore optimizer, scheduler, and RNG"): + checkpoint_module._validate_checkpoint_contract(args, [SimpleNamespace(role="actor")], tmp_path) + + +def test_restored_scheduler_is_not_advanced_twice(): + args = SimpleNamespace(no_load_optim=False, finetune=False, reset_optimizer_states=False) + assert checkpoint_module.scheduler_state_was_restored(args, resumed_from_megatron=True) + args.no_load_optim = True + assert not checkpoint_module.scheduler_state_was_restored(args, resumed_from_megatron=True) + + +def test_checkpoint_wrapper_restores_optimizer_scheduler_rng_and_next_step_loss(monkeypatch, tmp_path): + torch.manual_seed(7) + source = torch.nn.Linear(3, 1) + source_optimizer = torch.optim.AdamW(source.parameters(), lr=0.01) + source_scheduler = torch.optim.lr_scheduler.StepLR(source_optimizer, step_size=1, gamma=0.5) + + def step(model, optimizer, scheduler): + inputs = torch.randn(4, 3) + targets = torch.randn(4, 1) + optimizer.zero_grad() + loss = torch.nn.functional.mse_loss(model(inputs), targets) + loss.backward() + optimizer.step() + scheduler.step() + return loss.detach() + + step(source, source_optimizer, source_scheduler) + saved_model = copy.deepcopy(source.state_dict()) + saved_optimizer = copy.deepcopy(source_optimizer.state_dict()) + saved_scheduler = copy.deepcopy(source_scheduler.state_dict()) + saved_rng = torch.get_rng_state().clone() + expected_loss = step(source, source_optimizer, source_scheduler) + expected_parameters = copy.deepcopy(source.state_dict()) + + resumed = torch.nn.Linear(3, 1) + resumed_optimizer = torch.optim.AdamW(resumed.parameters(), lr=0.01) + resumed_scheduler = torch.optim.lr_scheduler.StepLR(resumed_optimizer, step_size=1, gamma=0.5) + + def fake_load_checkpoint_megatron(*, ddp_model, optimizer, opt_param_scheduler, **_): + ddp_model[0].load_state_dict(saved_model) + optimizer.load_state_dict(saved_optimizer) + opt_param_scheduler.load_state_dict(saved_scheduler) + torch.set_rng_state(saved_rng) + return 1, 0 + + monkeypatch.setattr(checkpoint_module, "get_args", lambda: SimpleNamespace(load=str(tmp_path))) + monkeypatch.setattr(checkpoint_module, "_is_dir_nonempty", lambda _: True) + monkeypatch.setattr(checkpoint_module, "is_megatron_checkpoint", lambda _: True) + monkeypatch.setattr(checkpoint_module, "_checkpoint_iteration_dir", lambda _: tmp_path) + monkeypatch.setattr(checkpoint_module, "_validate_checkpoint_contract", lambda *_: None) + monkeypatch.setattr(checkpoint_module, "_load_checkpoint_megatron", fake_load_checkpoint_megatron) + + checkpoint_module.load_checkpoint([resumed], resumed_optimizer, resumed_scheduler, None, False) + actual_loss = step(resumed, resumed_optimizer, resumed_scheduler) + + torch.testing.assert_close(actual_loss, expected_loss) + assert resumed_scheduler.state_dict() == source_scheduler.state_dict() + for name, parameter in resumed.state_dict().items(): + torch.testing.assert_close(parameter, expected_parameters[name]) + + +def test_critic_rejects_reward_model_metadata(monkeypatch, tmp_path): + fake_dist_checkpointing = SimpleNamespace( + load_common_state_dict=lambda path: { + "args": SimpleNamespace( + sft_objective="reward_model", + head_type="reward_model_terminal_v1", + checkpoint_role="actor", + ) + }, + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + with pytest.raises(RuntimeError, match="PPO critic load rejects"): + checkpoint_module._validate_checkpoint_contract(SimpleNamespace(), [SimpleNamespace(role="critic")], tmp_path) diff --git a/tests/backends/megatron/test_reward_model_loss.py b/tests/backends/megatron/test_reward_model_loss.py new file mode 100644 index 000000000..943afec22 --- /dev/null +++ b/tests/backends/megatron/test_reward_model_loss.py @@ -0,0 +1,94 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Reward-model loss, pooling, and metric contracts.""" + +from argparse import Namespace +from types import SimpleNamespace + +import pytest +import torch + + +try: + from relax.backends.megatron.loss import reward_model_loss_function +except Exception as exc: + pytest.skip(f"Megatron reward-model loss unavailable: {exc}", allow_module_level=True) + + +def _batch(): + branches = [ + torch.tensor([10, 11, 12]), + torch.tensor([20, 21]), + torch.tensor([30, 31, 32, 33]), + torch.tensor([40, 41]), + ] + lengths = [len(branch) for branch in branches] + packed = torch.cat(branches) + return { + "total_lengths": lengths, + "response_lengths": lengths, + "score_positions": [2, 1, 3, 1], + "raw_loss_masks": [ + torch.tensor([0, 1, 1]), + torch.tensor([0, 1]), + torch.tensor([0, 0, 1, 1]), + torch.tensor([0, 1]), + ], + "tokens": packed.unsqueeze(0), + "unconcat_tokens": branches, + "packed_seq_params": SimpleNamespace(cu_seqlens_q=torch.tensor([0, 3, 5, 9, 11])), + "preference_branch_pair_ids": [7, 8, 7, 8], + "preference_is_chosen": [False, True, True, False], + } + + +def test_reward_model_loss_uses_pair_identity_after_branch_reordering_and_preserves_gradient(): + batch = _batch() + flat = torch.arange(11, dtype=torch.float32, requires_grad=True) + loss, metrics = reward_model_loss_function(Namespace(), batch, flat.reshape(1, 11, 1), lambda value: value) + + expected_margins = torch.tensor([8.0 - 2.0, 4.0 - 10.0]) + expected = -torch.nn.functional.logsigmoid(expected_margins) + assert torch.allclose(loss, expected.sum()) + assert set(metrics) == { + "rm/loss", + "rm/score_chosen_mean", + "rm/score_rejected_mean", + "rm/score_margin_mean", + "rm/accuracy", + "rm/_score_chosen_second_moment", + "rm/_score_rejected_second_moment", + } + loss.backward() + assert flat.grad is not None + assert torch.count_nonzero(flat.grad).item() == 4 + + +@pytest.mark.parametrize( + ("mutation", "match"), + [ + (lambda batch: batch["raw_loss_masks"][0].zero_(), "raw_loss_mask"), + (lambda batch: batch["tokens"][0].__setitem__(2, 999), "terminal token"), + ( + lambda batch: setattr(batch["packed_seq_params"], "cu_seqlens_q", torch.tensor([0, 2, 5, 9, 11])), + "cu_seqlens", + ), + ], +) +def test_reward_model_pooling_rejects_mask_token_and_segment_misalignment(mutation, match): + batch = _batch() + mutation(batch) + with pytest.raises(ValueError, match=match): + reward_model_loss_function(Namespace(), batch, torch.zeros(1, 11, 1), lambda value: value) + + +def test_reward_model_pooling_allows_only_one_trailing_padding_segment(): + batch = _batch() + batch["tokens"] = torch.nn.functional.pad(batch["tokens"], (0, 5)) + batch["packed_seq_params"].cu_seqlens_q = torch.tensor([0, 3, 5, 9, 11, 16]) + logits = torch.zeros(1, 16, 1) + reward_model_loss_function(Namespace(), batch, logits, lambda value: value) + + batch["packed_seq_params"].cu_seqlens_q = torch.tensor([0, 3, 5, 9, 11, 14, 16]) + with pytest.raises(ValueError, match="at most one trailing padding"): + reward_model_loss_function(Namespace(), batch, logits, lambda value: value) diff --git a/tests/backends/megatron/test_sft_train_actor_eval.py b/tests/backends/megatron/test_sft_train_actor_eval.py index f3869e74b..0b6d2a4f8 100644 --- a/tests/backends/megatron/test_sft_train_actor_eval.py +++ b/tests/backends/megatron/test_sft_train_actor_eval.py @@ -5,21 +5,13 @@ from argparse import Namespace -import pytest - - -# Importing relax.backends.megatron.actor pulls in CUDA-only deps. Skip the -# whole module on CPU-only envs — matches the pattern used in -# tests/backends/megatron/test_sft_train_data_fields.py. -try: - from relax.backends.megatron.actor import _should_run_sft_eval # noqa: F401 -except (ImportError, AssertionError) as _exc: - pytest.skip(f"relax.backends.megatron.actor unavailable: {_exc}", allow_module_level=True) +from relax.engine.sft.runtime import should_run_sft_eval def _mk_actor_args(): return Namespace( loss_type="sft", + sft_objective="causal_lm", compute_advantages_and_returns=False, eval_prompt_data=["eval", "/dev/null"], eval_size=None, @@ -36,25 +28,34 @@ def _mk_actor_args(): def test_should_run_sft_eval_at_interval_boundary(): args = _mk_actor_args() - assert _should_run_sft_eval(args, rollout_id=9) is True - assert _should_run_sft_eval(args, rollout_id=19) is True - assert _should_run_sft_eval(args, rollout_id=4) is False - assert _should_run_sft_eval(args, rollout_id=0) is False + assert should_run_sft_eval(args, completed_steps=10) is True + assert should_run_sft_eval(args, completed_steps=20) is True + assert should_run_sft_eval(args, completed_steps=5) is False + assert should_run_sft_eval(args, completed_steps=0) is False + + +def test_preference_eval_includes_true_baseline_and_final_independent_of_interval(): + args = _mk_actor_args() + args.sft_objective = "reward_model" + args.eval_interval = 200 + assert should_run_sft_eval(args, completed_steps=0) is True + assert should_run_sft_eval(args, completed_steps=20) is True + assert should_run_sft_eval(args, completed_steps=1) is False def test_should_run_sft_eval_disabled_when_no_interval(): args = _mk_actor_args() args.eval_interval = None - assert _should_run_sft_eval(args, rollout_id=9) is False + assert should_run_sft_eval(args, completed_steps=10) is False def test_should_run_sft_eval_disabled_when_no_eval_source(): args = _mk_actor_args() args.eval_prompt_data = None - assert _should_run_sft_eval(args, rollout_id=9) is False + assert should_run_sft_eval(args, completed_steps=10) is False def test_should_run_sft_eval_disabled_for_non_sft(): args = _mk_actor_args() args.loss_type = "policy_loss" - assert _should_run_sft_eval(args, rollout_id=9) is False + assert should_run_sft_eval(args, completed_steps=10) is False diff --git a/tests/engine/sft/eval/test_acceptance.py b/tests/engine/sft/eval/test_acceptance.py new file mode 100644 index 000000000..11e3d0774 --- /dev/null +++ b/tests/engine/sft/eval/test_acceptance.py @@ -0,0 +1,71 @@ +# Copyright (c) 2026 Relax Authors. All Rights Reserved. + +"""Golden tests for RFC paired-bootstrap and artifact semantics.""" + +import json +from types import SimpleNamespace + +import numpy as np +import pytest + +from relax.engine.sft.eval.acceptance import ( + encoded_pair_id, + paired_bootstrap, + record_probe_contract, + write_pair_artifacts, +) + + +def test_paired_bootstrap_matches_pcg64_float64_golden_fixture(): + result = paired_bootstrap([1.0, 0.0, 1.0, 0.5]) + assert result["point_estimate"] == 0.625 + assert result["lower_95"] == 0.25 + assert result["indices_sha256"] == "dc7ec9501aead17b5115aad49b487302aed95c384d6c2aadcf67b56a849ef53f" + assert result["replicates_sha256"] == "52f63cf64c72be2904c2911052092af8fc2cd2f05444fa17898c79a1dc22e174" + assert result["passes_lower_bound_gt_0_50"] is False + + +def _pair(pair_id: str, token: int): + return SimpleNamespace( + pair_id=pair_id, + chosen_tokens=np.asarray([1, token]), + rejected_tokens=np.asarray([1, token + 1]), + chosen_loss_mask=np.asarray([0, 1]), + rejected_loss_mask=np.asarray([0, 1]), + chosen_score_position=1, + rejected_score_position=1, + ) + + +def test_pair_artifacts_preserve_original_ids_and_require_identical_final_plan(tmp_path): + pairs = [_pair(f"pair-{index}", index) for index in range(4)] + record_probe_contract(str(tmp_path), "reward_model", 0, pairs, expected_pair_count=4) + rows = [ + { + "encoded_pair_id": encoded_pair_id(pair.pair_id), + "chosen_score": float(index + 1), + "rejected_score": 0.0, + "pair_loss": 0.1, + } + for index, pair in enumerate(pairs) + ] + plan = [ + {"rank": 0, "chunk": 0, "batch": 0, "microbatch": 0, "encoded_pair_ids": [r["encoded_pair_id"] for r in rows]} + ] + write_pair_artifacts(str(tmp_path), "reward_model", 0, rows, plan) + record_probe_contract(str(tmp_path), "reward_model", 4, pairs, expected_pair_count=4) + write_pair_artifacts(str(tmp_path), "reward_model", 4, rows, plan) + + pair_path = tmp_path / "preference_eval" / "reward_model-step-0000004-pairs.jsonl" + written = [json.loads(line) for line in pair_path.read_text(encoding="utf-8").splitlines()] + assert [row["pair_id"] for row in written] == [pair.pair_id for pair in pairs] + assert set(written[0]) == {"pair_id", "chosen_score", "rejected_score", "pair_loss"} + + changed_plan = [{**plan[0], "encoded_pair_ids": list(reversed(plan[0]["encoded_pair_ids"]))}] + with pytest.raises(RuntimeError, match="batch plan changed"): + write_pair_artifacts(str(tmp_path), "reward_model", 4, rows, changed_plan) + + +def test_probe_contract_rejects_any_count_other_than_frozen_512(tmp_path): + with pytest.raises(RuntimeError, match="exactly 512 probe pairs"): + record_probe_contract(str(tmp_path), "reward_model", 0, [_pair("pair-0", 0)]) diff --git a/tests/engine/sft/eval/test_preference.py b/tests/engine/sft/eval/test_preference.py index 374fda08f..eb9201094 100644 --- a/tests/engine/sft/eval/test_preference.py +++ b/tests/engine/sft/eval/test_preference.py @@ -3,7 +3,19 @@ import pytest import torch -from relax.engine.sft.eval.preference import finalize_pair_metrics, pair_metric_sums +from relax.engine.sft.eval.preference import compute_reward_model_eval_step, finalize_pair_metrics, pair_metric_sums + + +def test_reward_model_eval_emits_one_score_per_branch_for_order_restoration(): + _, outputs = compute_reward_model_eval_step( + torch.tensor([0.0, 1.0, 2.0, 3.0]), + total_lengths=[2, 2], + score_positions=[1, 1], + ) + + assert len(outputs["scores"]) == 2 + assert all(score.ndim == 0 for score in outputs["scores"]) + assert torch.stack(outputs["scores"]).tolist() == [1.0, 3.0] def test_pair_metric_sums_and_finalize_keep_ties_explicit(): diff --git a/tests/utils/training/test_preference_utils.py b/tests/utils/training/test_preference_utils.py index 1456e8017..5c91308cf 100644 --- a/tests/utils/training/test_preference_utils.py +++ b/tests/utils/training/test_preference_utils.py @@ -100,6 +100,24 @@ def test_reward_model_pair_loss_matches_independent_reference_and_gradient(): assert torch.allclose(actual_grad, chosen.grad, rtol=1e-6, atol=1e-6) +def test_reward_model_pair_loss_uses_shared_tensor_condition(monkeypatch): + calls = [] + monkeypatch.setattr( + "relax.utils.training.preference_utils.require_tensor_condition", + lambda condition, message: calls.append((condition, message)), + ) + + reward_model_pair_loss(torch.tensor([1.0]), torch.tensor([0.0])) + + assert len(calls) == 1 + assert "finite" in calls[0][1] + + +def test_reward_model_pair_loss_rejects_non_finite_cpu_margin(): + with pytest.raises(ValueError, match="finite"): + reward_model_pair_loss(torch.tensor([float("inf")]), torch.tensor([0.0])) + + def test_select_packed_sequence_scores_preserves_pair_order_and_gradient(): flat_logits = torch.arange(10, dtype=torch.float32, requires_grad=True) logits = flat_logits.reshape(1, 10, 1) From 62b875976432f6ed92bf72d43b562b227cfe50f6 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 02:11:16 +0800 Subject: [PATCH 15/25] fix(sft): unblock colocate baseline eval MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Break the step-zero evaluation wait cycle - Treat the first preference eval chunk as the colocate actor's initial input - Preserve the baseline barrier before exposing the step-zero train partition - Keep causal SFT, RL, and resumed steps gated on their normal train partitions --- # ✅ Tests ## Cover colocate partition readiness - Verify preference step zero accepts only the first baseline eval chunk - Verify causal SFT and resumed preference steps retain existing readiness behavior --- relax/components/actor.py | 11 +++++--- relax/engine/sft/runtime.py | 16 ++++++++++++ tests/components/test_actor_sft_partition.py | 27 ++++++++++++++++++++ 3 files changed, 51 insertions(+), 3 deletions(-) diff --git a/relax/components/actor.py b/relax/components/actor.py index e96aef501..5e6b0a855 100644 --- a/relax/components/actor.py +++ b/relax/components/actor.py @@ -14,7 +14,13 @@ from relax.components.base import Base from relax.distributed.coordination import PeerStepBarrier, RolloutOffloadBarrier from relax.distributed.ray.placement_group import allocate_train_group -from relax.engine.sft.runtime import is_preference_mode, is_sft_mode, sft_partition_id, sft_task_name +from relax.engine.sft.runtime import ( + actor_training_input_ready, + is_preference_mode, + is_sft_mode, + sft_partition_id, + sft_task_name, +) from relax.utils.async_utils import run from relax.utils.opd.opd_utils import set_managed_opd_teacher_on_train_group @@ -229,9 +235,8 @@ def _wait_for_rollout_data(self) -> bool: True if data is ready and training can proceed, False if should continue waiting (caller should skip this iteration) """ - partition_id = sft_partition_id(self.config, self.step) partition_list = run(self.data_system_client.async_get_partition_list()) - if partition_list is None or partition_id not in partition_list: + if not actor_training_input_ready(self.config, self.step, partition_list): time.sleep(1) return False diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index cd3376c98..ae0892cb4 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -8,6 +8,7 @@ """ import math +import re from argparse import Namespace @@ -150,6 +151,21 @@ def should_run_sft_eval(args: Namespace, completed_steps: int) -> bool: return completed_steps > 0 and completed_steps % interval == 0 +def actor_training_input_ready(args: Namespace, step: int, partition_ids: list[str] | None) -> bool: + """Allow the backend to enter step 0 when its preference baseline is ready. + + In colocate mode the Actor service normally waits for the train partition + before calling the backend. Preference producers intentionally publish and + drain the step-0 eval partition first, so that baseline partition is the + backend's first input and must also release the service-level wait. + """ + if not partition_ids: + return False + if step == 0 and is_preference_mode(args) and should_run_sft_eval(args, completed_steps=0): + return any(re.fullmatch(r"sft_eval_0_n\d+_0", partition_id) for partition_id in partition_ids) + return sft_partition_id(args, step) in partition_ids + + def should_run_sft_predict(args: Namespace, rollout_id: int) -> bool: """SFT periodic predict triggers every ``--sft-predict-interval`` steps. diff --git a/tests/components/test_actor_sft_partition.py b/tests/components/test_actor_sft_partition.py index 84965cbe8..c07f98661 100644 --- a/tests/components/test_actor_sft_partition.py +++ b/tests/components/test_actor_sft_partition.py @@ -42,3 +42,30 @@ def test_actor_helpers_emit_train_partition_under_rl(): assert sft_partition_id(rl_cfg, 5) == "train_5" # NOTE: components/actor.py uses "train_actor" historically; preserve that for RL. assert sft_task_name(rl_cfg, component="actor") == "train_actor" + + +def test_colocate_preference_step_zero_starts_when_baseline_partition_is_ready(): + from relax.engine.sft.runtime import actor_training_input_ready + + cfg = _mk_actor_config(loss_type="sft") + cfg.sft_objective = "reward_model" + cfg.eval_prompt_data = ["task31", "heldout.parquet"] + cfg.eval_size = None + cfg.eval_interval = 200 + + assert actor_training_input_ready(cfg, 0, ["sft_eval_0_n2_0"]) + assert not actor_training_input_ready(cfg, 0, []) + assert not actor_training_input_ready(cfg, 0, ["sft_0"]) + assert not actor_training_input_ready(cfg, 0, ["sft_eval_0_n2_1"]) + assert not actor_training_input_ready(cfg, 1, ["sft_eval_1_n2_0"]) + assert actor_training_input_ready(cfg, 1, ["sft_1"]) + + +def test_actor_training_partition_remains_the_normal_readiness_signal(): + from relax.engine.sft.runtime import actor_training_input_ready + + cfg = _mk_actor_config(loss_type="sft") + cfg.sft_objective = "causal_lm" + + assert actor_training_input_ready(cfg, 0, ["sft_0"]) + assert not actor_training_input_ready(cfg, 0, ["sft_eval_0_n2_0"]) From a5b43c5c9b472c1ac089ad86523b976f38da6d33 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 02:41:04 +0800 Subject: [PATCH 16/25] fix(sft): preserve preference eval identity MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Keep preference outputs bound to original pairs - Restore per-sample forward outputs whenever the iterator supplies a packed index schedule - Validate packed schedules before reordering scores and log probabilities ## Preserve the complete fixed probe - Consume all 512 preference pairs with capacity-bounded partial chunks - Use actual per-rank and global batch sizes for final chunks - Reject chunk plans that cannot divide cleanly across data-parallel ranks ## Correct causal SFT prediction cadence - Evaluate prediction intervals against completed optimizer steps - Prevent baseline and pre-boundary prediction triggers --- # ✅ Tests ## Cover ordering, chunking, and scheduling regressions - Test packed output restoration independently of the dynamic-batch flag - Cover probe chunk plans across small, uneven, exact, and oversized batch sizes - Verify completed-step prediction boundaries --- relax/backends/megatron/model.py | 23 ++++++--- relax/components/sft.py | 49 +++++++++++++------ relax/engine/sft/eval/acceptance.py | 22 +++++++++ relax/engine/sft/eval/runner.py | 14 +++++- relax/engine/sft/runtime.py | 6 +-- .../megatron/test_reward_model_loss.py | 26 ++++++++++ .../megatron/test_sft_train_actor_eval.py | 13 ++++- tests/engine/sft/eval/test_acceptance.py | 25 ++++++++++ 8 files changed, 149 insertions(+), 29 deletions(-) diff --git a/relax/backends/megatron/model.py b/relax/backends/megatron/model.py index a2355d773..8d0032735 100644 --- a/relax/backends/megatron/model.py +++ b/relax/backends/megatron/model.py @@ -663,6 +663,19 @@ def force_param_sync(model_chunks: Sequence[DDP]) -> None: model_chunk.start_param_sync(force_sync=True) +def _restore_micro_batch_output_order(values: list, micro_batch_indices: list[list[int]]) -> list: + """Restore per-sample outputs from packed micro-batch order.""" + origin_indices = sum(micro_batch_indices, []) + if len(values) != len(origin_indices): + return values + if sorted(origin_indices) != list(range(len(origin_indices))): + raise RuntimeError("micro-batch indices must be a complete permutation of original sample indices") + origin_values = [None] * len(values) + for value, origin_index in zip(values, origin_indices, strict=False): + origin_values[origin_index] = value + return origin_values + + @torch.no_grad() def forward_only( f: Callable[..., dict[str, list[torch.Tensor]]], @@ -894,21 +907,17 @@ def _inject_meta(logits, *, _orig=f_partial, _meta=dcp_meta): assert isinstance(value[key], list) values += value[key] - if args.use_dynamic_batch_size: + micro_batch_indices = data_iterator[0].micro_batch_indices + if micro_batch_indices is not None: # TODO: This is ugly... Find a better way to make the data have the same order. # TODO: move this out of the loop. - origin_indices = sum(data_iterator[0].micro_batch_indices, []) # Per-sample callbacks (log_probs/values) emit one tensor per # sample, so values aligns with origin_indices and we can # restore the pre-balance order. Per-microbatch callbacks # (e.g. compute_sft_eval_step) emit one aggregate per # microbatch — len(values) == num_microbatches, not # num_samples — and have no per-sample order to restore. - if len(values) == len(origin_indices): - origin_values = [None] * len(values) - for value, origin_index in zip(values, origin_indices, strict=False): - origin_values[origin_index] = value - values = origin_values + values = _restore_micro_batch_output_order(values, micro_batch_indices) rollout_data[f"{store_prefix}{key}"] = values return rollout_data diff --git a/relax/components/sft.py b/relax/components/sft.py index c3de24ab7..9da572583 100644 --- a/relax/components/sft.py +++ b/relax/components/sft.py @@ -434,7 +434,11 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: self._logger.warning("Eval source produced 0 valid samples; skipping eval push.") return if is_preference_mode(self.config): - from relax.engine.sft.eval.acceptance import record_probe_contract + from relax.engine.sft.eval.acceptance import ( + preference_eval_chunk_sizes, + preference_eval_local_batch_sizes, + record_probe_contract, + ) samples = sorted(samples, key=lambda pair: pair.pair_id) record_probe_contract( @@ -444,15 +448,13 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: samples, ) - # Pad sub-gbs eval pools with random resamples so the eval set always - # forms at least one full ``global_batch_size`` chunk. Without this the - # chunking loop below would skip eval entirely (n_chunks==0), and the - # consumer — which enters ``run_sft_eval`` purely on interval — would - # block forever waiting for partitions that never come. Seeded by step - # so the padding is reproducible across restarts. + # Causal eval pads sub-GBS pools because its legacy consumer requests a + # fixed batch size. Preference eval uses actual partial-chunk sizes and + # must preserve every unique probe pair without padding. gbs = self.config.global_batch_size n_original = len(samples) - if n_original < gbs: + preference_mode = is_preference_mode(self.config) + if n_original < gbs and not preference_mode: rng = random.Random(completed_steps) pad_count = gbs - n_original samples = list(samples) + rng.choices(samples, k=pad_count) @@ -463,7 +465,7 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: f"interpret with caution." ) - if is_preference_mode(self.config): + if preference_mode: backend_batch, preference_custom_meta = pack_preference_pairs_for_tq(samples) else: backend_batch = pack_samples_for_tq( @@ -480,15 +482,28 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: await self._wait_for_partition_drained(f"sft_{completed_steps - 1}") chunk_size = self.config.global_batch_size - # Drop trailing samples that don't fill a full chunk. The consumer's + # Causal eval retains the legacy full-chunk requirement. Preference + # eval uses actual per-chunk batch sizes below and never drops pairs. + # The causal consumer's # `_get_data_from_transfer_queue` calls `tq.get_meta(batch_size=...)` # which returns size=0 when the partition has fewer than batch_size # samples, so a partial last chunk would never be marked consumed and # the actor's `while not all_consumed` loop would spin forever (it # already burned a full eval round in the wild — see the # `[get_data_profile] samples=0` log spam). - n_chunks = n_samples // chunk_size - n_dropped = n_samples - n_chunks * chunk_size + if preference_mode: + chunk_sizes = preference_eval_chunk_sizes(n_samples, chunk_size) + preference_eval_local_batch_sizes( + n_samples, + chunk_size, + int(getattr(self.config, "data_parallel_size", 1)), + ) + n_chunks = len(chunk_sizes) + n_dropped = 0 + else: + n_chunks = n_samples // chunk_size + n_dropped = n_samples - n_chunks * chunk_size + chunk_sizes = [chunk_size] * n_chunks if n_chunks == 0: self._logger.warning( f"Eval @ completed_steps={completed_steps}: eval pool of {n_samples} samples is smaller than " @@ -507,12 +522,14 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: # step. On timeout we clear our own pending chunk and bail. chunk_drain_timeout = float(getattr(self.config, "sft_eval_chunk_drain_timeout_sec", 600.0)) self._logger.info( - f"Eval @ completed_steps={completed_steps}: pushing {n_chunks * chunk_size} samples " + f"Eval @ completed_steps={completed_steps}: pushing {sum(chunk_sizes)} samples " f"in {n_chunks} chunk(s) of {chunk_size}." ) - for chunk_idx in range(n_chunks): - s = chunk_idx * chunk_size - e = s + chunk_size + offset = 0 + for chunk_idx, current_chunk_size in enumerate(chunk_sizes): + s = offset + e = s + current_chunk_size + offset = e chunk = {k: v[s:e] for k, v in backend_batch.items()} partition_id = f"sft_eval_{completed_steps}_n{n_chunks}_{chunk_idx}" await self.data_system_client.async_put( diff --git a/relax/engine/sft/eval/acceptance.py b/relax/engine/sft/eval/acceptance.py index fde34a2aa..846f3c29e 100644 --- a/relax/engine/sft/eval/acceptance.py +++ b/relax/engine/sft/eval/acceptance.py @@ -11,6 +11,26 @@ PREFERENCE_PROBE_PAIR_COUNT = 512 +def preference_eval_chunk_sizes(pair_count: int, global_batch_size: int) -> list[int]: + """Split every real probe pair into capacity-bounded eval chunks.""" + if pair_count <= 0 or global_batch_size <= 0: + raise ValueError("preference eval pair count and global batch size must be positive") + full_chunks, remainder = divmod(pair_count, global_batch_size) + return [global_batch_size] * full_chunks + ([remainder] if remainder else []) + + +def preference_eval_local_batch_sizes(pair_count: int, global_batch_size: int, dp_size: int) -> list[int]: + if dp_size <= 0: + raise ValueError("preference eval data-parallel size must be positive") + chunk_sizes = preference_eval_chunk_sizes(pair_count, global_batch_size) + invalid = [size for size in chunk_sizes if size % dp_size != 0] + if invalid: + raise ValueError( + f"preference eval chunk sizes must be divisible by data-parallel size: chunks={invalid}, dp={dp_size}" + ) + return [size // dp_size for size in chunk_sizes] + + def encoded_pair_id(pair_id: str) -> int: return int.from_bytes(hashlib.sha256(pair_id.encode()).digest()[:8], "big") >> 1 @@ -178,6 +198,8 @@ def write_pair_artifacts( "canonical_sha256", "encoded_pair_id", "paired_bootstrap", + "preference_eval_chunk_sizes", + "preference_eval_local_batch_sizes", "record_probe_contract", "write_pair_artifacts", ] diff --git a/relax/engine/sft/eval/runner.py b/relax/engine/sft/eval/runner.py index 9d6640504..3e33922e2 100644 --- a/relax/engine/sft/eval/runner.py +++ b/relax/engine/sft/eval/runner.py @@ -195,6 +195,11 @@ def _run_preference_eval(actor, rollout_id: int) -> None: from relax.backends.megatron.data import expand_preference_rollout_data, get_data_iterator from relax.backends.megatron.initialize import is_megatron_main_rank from relax.backends.megatron.model import forward_only + from relax.engine.sft.eval.acceptance import ( + PREFERENCE_PROBE_PAIR_COUNT, + preference_eval_chunk_sizes, + preference_eval_local_batch_sizes, + ) from relax.engine.sft.eval.preference import ( compute_reward_model_eval_step, finalize_pair_metrics, @@ -204,7 +209,7 @@ def _run_preference_eval(actor, rollout_id: int) -> None: args = actor.args task_name = "sft_eval" - batch_size = args.global_batch_size // mpu.get_data_parallel_world_size(with_context_parallel=False) + dp_size = mpu.get_data_parallel_world_size(with_context_parallel=False) data_fields = [ "pair_ids", "chosen_tokens", @@ -217,12 +222,16 @@ def _run_preference_eval(actor, rollout_id: int) -> None: "rejected_score_positions", ] n_chunks = _wait_for_eval_chunk_count(actor, rollout_id) + chunk_sizes = preference_eval_chunk_sizes(PREFERENCE_PROBE_PAIR_COUNT, args.global_batch_size) + local_batch_sizes = preference_eval_local_batch_sizes(PREFERENCE_PROBE_PAIR_COUNT, args.global_batch_size, dp_size) + if len(chunk_sizes) != n_chunks: + raise RuntimeError(f"preference eval chunk plan mismatch: producer={n_chunks}, consumer={len(chunk_sizes)}") local = torch.zeros(7, device=device_utils.make_current_torch_device(), dtype=torch.float64) local_rows: list[dict] = [] local_plan: list[dict] = [] started = time.monotonic() with timer("preference_eval"): - for chunk_idx in range(n_chunks): + for chunk_idx, (global_chunk_size, batch_size) in enumerate(zip(chunk_sizes, local_batch_sizes, strict=True)): partition_id = f"sft_eval_{rollout_id}_n{n_chunks}_{chunk_idx}" _wait_for_eval_partition_present(actor, partition_id) batch_index = 0 @@ -234,6 +243,7 @@ def _run_preference_eval(actor, rollout_id: int) -> None: continue batch_index += 1 rollout_data = expand_preference_rollout_data(pair_rows) + rollout_data["dynamic_global_batch_size"] = global_chunk_size data_iterator, num_microbatches = get_data_iterator(args, actor.model, rollout_data) for microbatch_index, branch_indices in enumerate(data_iterator[0].micro_batch_indices): encoded_ids = [] diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index ae0892cb4..e91772fcb 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -166,8 +166,8 @@ def actor_training_input_ready(args: Namespace, step: int, partition_ids: list[s return sft_partition_id(args, step) in partition_ids -def should_run_sft_predict(args: Namespace, rollout_id: int) -> bool: - """SFT periodic predict triggers every ``--sft-predict-interval`` steps. +def should_run_sft_predict(args: Namespace, completed_steps: int) -> bool: + """SFT periodic predict triggers after each completed interval. Argparse already validated ``--loss-type sft``, ``--save``, and the eval data source, so we only need the interval check here. @@ -175,4 +175,4 @@ def should_run_sft_predict(args: Namespace, rollout_id: int) -> bool: interval = getattr(args, "sft_predict_interval", None) if interval is None or interval <= 0: return False - return (rollout_id + 1) % interval == 0 + return completed_steps > 0 and completed_steps % interval == 0 diff --git a/tests/backends/megatron/test_reward_model_loss.py b/tests/backends/megatron/test_reward_model_loss.py index 943afec22..bbb6fa856 100644 --- a/tests/backends/megatron/test_reward_model_loss.py +++ b/tests/backends/megatron/test_reward_model_loss.py @@ -11,10 +11,36 @@ try: from relax.backends.megatron.loss import reward_model_loss_function + from relax.backends.megatron.model import _restore_micro_batch_output_order except Exception as exc: pytest.skip(f"Megatron reward-model loss unavailable: {exc}", allow_module_level=True) +def test_preference_outputs_restore_original_order_without_dynamic_batch_flag(): + packed_values = [ + "pair-2-chosen", + "pair-2-rejected", + "pair-0-chosen", + "pair-0-rejected", + "pair-1-chosen", + "pair-1-rejected", + ] + schedule = [[4, 5, 0, 1], [2, 3]] + + assert _restore_micro_batch_output_order(packed_values, schedule) == [ + "pair-0-chosen", + "pair-0-rejected", + "pair-1-chosen", + "pair-1-rejected", + "pair-2-chosen", + "pair-2-rejected", + ] + assert _restore_micro_batch_output_order(["aggregate-0", "aggregate-1"], schedule) == [ + "aggregate-0", + "aggregate-1", + ] + + def _batch(): branches = [ torch.tensor([10, 11, 12]), diff --git a/tests/backends/megatron/test_sft_train_actor_eval.py b/tests/backends/megatron/test_sft_train_actor_eval.py index 0b6d2a4f8..dcfe1ee60 100644 --- a/tests/backends/megatron/test_sft_train_actor_eval.py +++ b/tests/backends/megatron/test_sft_train_actor_eval.py @@ -5,7 +5,7 @@ from argparse import Namespace -from relax.engine.sft.runtime import should_run_sft_eval +from relax.engine.sft.runtime import should_run_sft_eval, should_run_sft_predict def _mk_actor_args(): @@ -59,3 +59,14 @@ def test_should_run_sft_eval_disabled_for_non_sft(): args = _mk_actor_args() args.loss_type = "policy_loss" assert should_run_sft_eval(args, completed_steps=10) is False + + +def test_should_run_sft_predict_uses_completed_step_boundaries(): + args = _mk_actor_args() + args.sft_predict_interval = 10 + + assert should_run_sft_predict(args, completed_steps=0) is False + assert should_run_sft_predict(args, completed_steps=9) is False + assert should_run_sft_predict(args, completed_steps=10) is True + assert should_run_sft_predict(args, completed_steps=19) is False + assert should_run_sft_predict(args, completed_steps=20) is True diff --git a/tests/engine/sft/eval/test_acceptance.py b/tests/engine/sft/eval/test_acceptance.py index 11e3d0774..626baf4e8 100644 --- a/tests/engine/sft/eval/test_acceptance.py +++ b/tests/engine/sft/eval/test_acceptance.py @@ -11,11 +11,36 @@ from relax.engine.sft.eval.acceptance import ( encoded_pair_id, paired_bootstrap, + preference_eval_chunk_sizes, + preference_eval_local_batch_sizes, record_probe_contract, write_pair_artifacts, ) +@pytest.mark.parametrize( + ("global_batch_size", "expected"), + [ + (1, [1] * 512), + (30, [30] * 17 + [2]), + (32, [32] * 16), + (512, [512]), + (513, [512]), + ], +) +def test_preference_eval_chunks_preserve_all_512_unique_pairs(global_batch_size, expected): + sizes = preference_eval_chunk_sizes(512, global_batch_size) + assert sizes == expected + assert sum(sizes) == 512 + assert max(sizes) <= global_batch_size + + +def test_preference_eval_partial_chunk_uses_actual_per_rank_batch_size(): + assert preference_eval_local_batch_sizes(512, 30, dp_size=2) == [15] * 17 + [1] + with pytest.raises(ValueError, match="divisible by data-parallel size"): + preference_eval_local_batch_sizes(512, 31, dp_size=2) + + def test_paired_bootstrap_matches_pcg64_float64_golden_fixture(): result = paired_bootstrap([1.0, 0.0, 1.0, 0.5]) assert result["point_estimate"] == 0.625 From 8942a54a45369a37debb68e6671bc8dfa70412ed Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 02:57:14 +0800 Subject: [PATCH 17/25] fix(sft): align async evaluation steps MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Use completed steps for every SFT post-train evaluation - Map zero-based SFT rollout IDs to completed optimizer-step values - Apply the same mapping to sync, hybrid, and fully-async training paths - Preserve zero-based rollout evaluation steps for RL and step zero for the preference baseline --- # ✅ Tests ## Cover SFT and RL evaluation-step mapping - Verify initial and interval-boundary rollout IDs for both training modes --- relax/backends/megatron/actor.py | 13 ++++++++++--- relax/engine/sft/runtime.py | 5 +++++ .../backends/megatron/test_sft_train_actor_eval.py | 12 +++++++++++- 3 files changed, 26 insertions(+), 4 deletions(-) diff --git a/relax/backends/megatron/actor.py b/relax/backends/megatron/actor.py index 03819f931..770a2c75b 100644 --- a/relax/backends/megatron/actor.py +++ b/relax/backends/megatron/actor.py @@ -34,6 +34,7 @@ from relax.engine.sft.eval.runner import run_sft_eval from relax.engine.sft.predict.runner import run_sft_predict from relax.engine.sft.runtime import ( + evaluation_step_for_rollout, is_preference_mode, is_sft_mode, sft_partition_id, @@ -1192,7 +1193,7 @@ def train_actor(self, rollout_id: int, rollout_data: RolloutBatch) -> None: # RL-only generative eval (uses SGLang via rollout_manager.eval). SFT # uses local eval/predict runner below. dist.barrier(group=get_gloo_group()) - self._run_step_evaluation(rollout_id + 1 if is_sft_mode(self.args) else rollout_id) + self._run_step_evaluation(evaluation_step_for_rollout(self.args, rollout_id)) # On the final training step the rollout component has already exited # its main loop, so nothing else awaits the eval handler. Block here @@ -1661,7 +1662,10 @@ def train_hybrid(self, rollout_id) -> None: self.update_weights() tracking_utils.flush_metrics(self.args, compute_rollout_step(self.args, rollout_id)) dist.barrier(group=get_gloo_group()) - self._run_step_evaluation(rollout_id, end_update_weight=True) + self._run_step_evaluation( + evaluation_step_for_rollout(self.args, rollout_id), + end_update_weight=True, + ) # On the final training step the rollout component has already exited # its main loop, so the eval just triggered above will not be awaited @@ -1744,7 +1748,10 @@ def train_async(self, rollout_id) -> None: rollout_only, actor_fwd_only = self._check_services_health() self.update_weights_fully_async(rollout_id, rollout_only=rollout_only, actor_fwd_only=actor_fwd_only) dist.barrier(group=get_gloo_group()) - self._run_step_evaluation(rollout_id, end_update_weight=True) + self._run_step_evaluation( + evaluation_step_for_rollout(self.args, rollout_id), + end_update_weight=True, + ) # On the final training step the rollout component has already # exited its main loop, so the eval just triggered above will not # be awaited anywhere. Block until it finishes; otherwise the diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index e91772fcb..5307f9fa7 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -176,3 +176,8 @@ def should_run_sft_predict(args: Namespace, completed_steps: int) -> bool: if interval is None or interval <= 0: return False return completed_steps > 0 and completed_steps % interval == 0 + + +def evaluation_step_for_rollout(args: Namespace, rollout_id: int) -> int: + """Map a zero-based training rollout to the evaluation step namespace.""" + return rollout_id + 1 if is_sft_mode(args) else rollout_id diff --git a/tests/backends/megatron/test_sft_train_actor_eval.py b/tests/backends/megatron/test_sft_train_actor_eval.py index dcfe1ee60..69752b96e 100644 --- a/tests/backends/megatron/test_sft_train_actor_eval.py +++ b/tests/backends/megatron/test_sft_train_actor_eval.py @@ -5,7 +5,7 @@ from argparse import Namespace -from relax.engine.sft.runtime import should_run_sft_eval, should_run_sft_predict +from relax.engine.sft.runtime import evaluation_step_for_rollout, should_run_sft_eval, should_run_sft_predict def _mk_actor_args(): @@ -70,3 +70,13 @@ def test_should_run_sft_predict_uses_completed_step_boundaries(): assert should_run_sft_predict(args, completed_steps=10) is True assert should_run_sft_predict(args, completed_steps=19) is False assert should_run_sft_predict(args, completed_steps=20) is True + + +def test_evaluation_step_mapping_is_completed_for_sft_and_zero_based_for_rl(): + args = _mk_actor_args() + assert evaluation_step_for_rollout(args, rollout_id=0) == 1 + assert evaluation_step_for_rollout(args, rollout_id=9) == 10 + + args.loss_type = "policy_loss" + assert evaluation_step_for_rollout(args, rollout_id=0) == 0 + assert evaluation_step_for_rollout(args, rollout_id=9) == 9 From e0ffa328a4acbaa2658f9520bcede03f718fedf0 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 03:22:53 +0800 Subject: [PATCH 18/25] fix(checkpoint): support Megatron formats MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Mirror Megatron checkpoint tracker semantics - Resolve release metadata to the official release checkpoint directory - Preserve iteration and checkpoint-step handling for non-release trackers - Honor an explicitly requested checkpoint step of zero - Reject invalid and negative checkpoint metadata with explicit errors ## Preserve legacy checkpoint compatibility - Detect distributed checkpoints before loading common state metadata - Delegate legacy SFT, DPO, and PPO checkpoints to the upstream Megatron loader - Reject legacy and model-only release checkpoints for reward-model resumes --- # ✅ Tests ## Cover checkpoint path and format contracts - Test release, zero, iteration, explicit step zero, checkpoint-step, invalid, and negative tracker values - Verify non-RM legacy checkpoints bypass distributed metadata and reach the upstream loader - Verify RM legacy and release checkpoints fail before checkpoint state is loaded --- relax/backends/megatron/checkpoint.py | 45 +++++-- .../megatron/test_reward_model_checkpoint.py | 117 +++++++++++++++++- 2 files changed, 151 insertions(+), 11 deletions(-) diff --git a/relax/backends/megatron/checkpoint.py b/relax/backends/megatron/checkpoint.py index 7f7811389..78afa5f69 100644 --- a/relax/backends/megatron/checkpoint.py +++ b/relax/backends/megatron/checkpoint.py @@ -113,15 +113,25 @@ def scheduler_state_was_restored(args, resumed_from_megatron: bool) -> bool: ) -def _checkpoint_iteration_dir(load_path: str | Path) -> Path: +def _checkpoint_iteration_dir(load_path: str | Path, ckpt_step: int | None = None) -> Path: path = Path(load_path) if re.fullmatch(r"iter_\d{7}", path.name): return path tracker = path / "latest_checkpointed_iteration.txt" try: - iteration = int(tracker.read_text(encoding="utf-8").strip()) - except (OSError, ValueError) as exc: + metadata = tracker.read_text(encoding="utf-8").strip() + except OSError as exc: raise RuntimeError(f"cannot resolve Megatron checkpoint iteration from {tracker}") from exc + if metadata == "release": + return path / "release" + try: + iteration = int(metadata) + except ValueError as exc: + raise RuntimeError(f"cannot resolve Megatron checkpoint iteration from {tracker}") from exc + if ckpt_step is not None: + iteration = int(ckpt_step) + if iteration < 0: + raise RuntimeError(f"Megatron checkpoint iteration must be non-negative, got {iteration}") return path / f"iter_{iteration:07d}" @@ -153,6 +163,23 @@ def _validate_reward_model_tensor_metadata(tensor_metadata: dict, hidden_size: i def _validate_checkpoint_contract(args, ddp_model, checkpoint_dir: Path) -> None: from megatron.core import dist_checkpointing + role = getattr(ddp_model[0], "role", "actor") + current_is_rm = ( + role == "actor" + and getattr(args, "loss_type", None) == "sft" + and getattr(args, "sft_objective", "causal_lm") == "reward_model" + ) + if current_is_rm and checkpoint_dir.name == "release": + raise RuntimeError( + "RM resume rejects release checkpoints because optimizer, scheduler, and RNG state are absent" + ) + if not dist_checkpointing.check_is_distributed_checkpoint(str(checkpoint_dir)): + if current_is_rm: + raise RuntimeError( + "RM resume requires a distributed checkpoint with contract metadata; legacy Megatron " + "checkpoints are not supported" + ) + return common = dist_checkpointing.load_common_state_dict(checkpoint_dir) saved_args = common.get("args") if saved_args is None: @@ -160,12 +187,6 @@ def _validate_checkpoint_contract(args, ddp_model, checkpoint_dir: Path) -> None saved_objective = _metadata_value(saved_args, "sft_objective") saved_head_type = _metadata_value(saved_args, "head_type") saved_role = _metadata_value(saved_args, "checkpoint_role") - role = getattr(ddp_model[0], "role", "actor") - current_is_rm = ( - role == "actor" - and getattr(args, "loss_type", None) == "sft" - and getattr(args, "sft_objective", "causal_lm") == "reward_model" - ) saved_is_rm = saved_objective == "reward_model" or saved_head_type == REWARD_MODEL_HEAD_TYPE if current_is_rm: @@ -203,7 +224,11 @@ def load_checkpoint(ddp_model, optimizer, opt_param_scheduler, checkpointing_con exist = Path(load_path).exists() and _is_dir_nonempty(load_path) if exist and is_megatron_checkpoint(load_path): - _validate_checkpoint_contract(args, ddp_model, _checkpoint_iteration_dir(load_path)) + _validate_checkpoint_contract( + args, + ddp_model, + _checkpoint_iteration_dir(load_path, getattr(args, "ckpt_step", None)), + ) try: return _load_checkpoint_megatron( ddp_model=ddp_model, diff --git a/tests/backends/megatron/test_reward_model_checkpoint.py b/tests/backends/megatron/test_reward_model_checkpoint.py index e55940726..5cd367d07 100644 --- a/tests/backends/megatron/test_reward_model_checkpoint.py +++ b/tests/backends/megatron/test_reward_model_checkpoint.py @@ -20,6 +20,42 @@ def __init__(self, shape): self.global_shape = shape +@pytest.mark.parametrize( + ("tracker_value", "expected_directory"), + [("0", "iter_0000000"), ("17", "iter_0000017"), ("release", "release")], +) +def test_checkpoint_iteration_dir_supports_megatron_tracker_formats(tmp_path, tracker_value, expected_directory): + (tmp_path / "latest_checkpointed_iteration.txt").write_text(tracker_value, encoding="utf-8") + assert checkpoint_module._checkpoint_iteration_dir(tmp_path) == tmp_path / expected_directory + + +def test_checkpoint_iteration_dir_rejects_invalid_tracker_metadata(tmp_path): + (tmp_path / "latest_checkpointed_iteration.txt").write_text("invalid", encoding="utf-8") + with pytest.raises(RuntimeError, match="cannot resolve Megatron checkpoint iteration"): + checkpoint_module._checkpoint_iteration_dir(tmp_path) + + +def test_checkpoint_iteration_dir_honors_explicit_checkpoint_step_for_iteration_tracker(tmp_path): + (tmp_path / "latest_checkpointed_iteration.txt").write_text("17", encoding="utf-8") + assert checkpoint_module._checkpoint_iteration_dir(tmp_path, ckpt_step=42) == tmp_path / "iter_0000042" + + +def test_checkpoint_iteration_dir_honors_explicit_zero_checkpoint_step(tmp_path): + (tmp_path / "latest_checkpointed_iteration.txt").write_text("17", encoding="utf-8") + assert checkpoint_module._checkpoint_iteration_dir(tmp_path, ckpt_step=0) == tmp_path / "iter_0000000" + + +def test_checkpoint_iteration_dir_keeps_release_when_checkpoint_step_is_set(tmp_path): + (tmp_path / "latest_checkpointed_iteration.txt").write_text("release", encoding="utf-8") + assert checkpoint_module._checkpoint_iteration_dir(tmp_path, ckpt_step=42) == tmp_path / "release" + + +def test_checkpoint_iteration_dir_rejects_negative_iterations(tmp_path): + (tmp_path / "latest_checkpointed_iteration.txt").write_text("-1", encoding="utf-8") + with pytest.raises(RuntimeError, match="must be non-negative"): + checkpoint_module._checkpoint_iteration_dir(tmp_path) + + def test_reward_model_tensor_metadata_accepts_exact_bias_free_head(): checkpoint_module._validate_reward_model_tensor_metadata( { @@ -61,6 +97,7 @@ def test_reward_model_tensor_metadata_rejects_missing_extra_and_wrong_shape(meta def test_reward_model_contract_rejects_critic_metadata_before_tensor_load(monkeypatch, tmp_path): calls = [] fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: True, load_common_state_dict=lambda path: { "args": SimpleNamespace( sft_objective="causal_lm", head_type="critic_value_terminal_v1", checkpoint_role="critic" @@ -86,8 +123,84 @@ def test_reward_model_contract_rejects_critic_metadata_before_tensor_load(monkey assert calls == [] +def test_reward_model_contract_rejects_release_checkpoint_before_metadata_load(monkeypatch, tmp_path): + calls = [] + import megatron.core + + monkeypatch.setattr( + megatron.core, + "dist_checkpointing", + SimpleNamespace(load_common_state_dict=lambda path: calls.append(path)), + ) + args = SimpleNamespace(loss_type="sft", sft_objective="reward_model") + with pytest.raises(RuntimeError, match="rejects release checkpoints"): + checkpoint_module._validate_checkpoint_contract(args, [SimpleNamespace(role="actor")], tmp_path / "release") + assert calls == [] + + +@pytest.mark.parametrize( + ("args", "role"), + [ + (SimpleNamespace(loss_type="sft", sft_objective="causal_lm"), "actor"), + (SimpleNamespace(loss_type="sft", sft_objective="dpo"), "actor"), + (SimpleNamespace(), "critic"), + ], +) +def test_non_reward_model_contract_defers_legacy_checkpoint_to_megatron(monkeypatch, tmp_path, args, role): + common_state_loads = [] + fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: False, + load_common_state_dict=lambda path: common_state_loads.append(path), + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + checkpoint_module._validate_checkpoint_contract(args, [SimpleNamespace(role=role)], tmp_path) + assert common_state_loads == [] + + +def test_reward_model_contract_rejects_legacy_checkpoint_before_metadata_load(monkeypatch, tmp_path): + common_state_loads = [] + fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: False, + load_common_state_dict=lambda path: common_state_loads.append(path), + ) + import megatron.core + + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + args = SimpleNamespace(loss_type="sft", sft_objective="reward_model") + with pytest.raises(RuntimeError, match="RM resume requires a distributed checkpoint"): + checkpoint_module._validate_checkpoint_contract(args, [SimpleNamespace(role="actor")], tmp_path) + assert common_state_loads == [] + + +def test_checkpoint_wrapper_delegates_non_reward_model_legacy_checkpoint(monkeypatch, tmp_path): + import megatron.core + + upstream_loads = [] + fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: False, + load_common_state_dict=lambda path: pytest.fail("legacy checkpoint must not use distributed common state"), + ) + args = SimpleNamespace(load=str(tmp_path), loss_type="sft", sft_objective="causal_lm", ckpt_step=None) + monkeypatch.setattr(megatron.core, "dist_checkpointing", fake_dist_checkpointing) + monkeypatch.setattr(checkpoint_module, "get_args", lambda: args) + monkeypatch.setattr(checkpoint_module, "_is_dir_nonempty", lambda _: True) + monkeypatch.setattr(checkpoint_module, "is_megatron_checkpoint", lambda _: True) + monkeypatch.setattr(checkpoint_module, "_checkpoint_iteration_dir", lambda *_: tmp_path / "iter_0000001") + monkeypatch.setattr( + checkpoint_module, + "_load_checkpoint_megatron", + lambda **kwargs: upstream_loads.append(kwargs) or (1, 0), + ) + + assert checkpoint_module.load_checkpoint([SimpleNamespace(role="actor")], None, None, None, False) == (1, 0) + assert len(upstream_loads) == 1 + + def test_reward_model_contract_accepts_complete_metadata_and_exact_head(monkeypatch, tmp_path): fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: True, load_common_state_dict=lambda path: { "args": SimpleNamespace( sft_objective="reward_model", @@ -115,6 +228,7 @@ def test_reward_model_contract_accepts_complete_metadata_and_exact_head(monkeypa @pytest.mark.parametrize("flag", ["no_load_optim", "no_load_rng", "finetune", "reset_optimizer_states"]) def test_reward_model_contract_rejects_partial_resume_flags(monkeypatch, tmp_path, flag): fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: True, load_common_state_dict=lambda path: { "args": SimpleNamespace( sft_objective="reward_model", @@ -178,7 +292,7 @@ def fake_load_checkpoint_megatron(*, ddp_model, optimizer, opt_param_scheduler, monkeypatch.setattr(checkpoint_module, "get_args", lambda: SimpleNamespace(load=str(tmp_path))) monkeypatch.setattr(checkpoint_module, "_is_dir_nonempty", lambda _: True) monkeypatch.setattr(checkpoint_module, "is_megatron_checkpoint", lambda _: True) - monkeypatch.setattr(checkpoint_module, "_checkpoint_iteration_dir", lambda _: tmp_path) + monkeypatch.setattr(checkpoint_module, "_checkpoint_iteration_dir", lambda *_: tmp_path) monkeypatch.setattr(checkpoint_module, "_validate_checkpoint_contract", lambda *_: None) monkeypatch.setattr(checkpoint_module, "_load_checkpoint_megatron", fake_load_checkpoint_megatron) @@ -193,6 +307,7 @@ def fake_load_checkpoint_megatron(*, ddp_model, optimizer, opt_param_scheduler, def test_critic_rejects_reward_model_metadata(monkeypatch, tmp_path): fake_dist_checkpointing = SimpleNamespace( + check_is_distributed_checkpoint=lambda path: True, load_common_state_dict=lambda path: { "args": SimpleNamespace( sft_objective="reward_model", From 38e0f2a0dfacaefcb2f0715c12d1b0b94007a95f Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 05:48:53 +0800 Subject: [PATCH 19/25] fix(sft): preserve preference eval pair IDs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Read pair identity after TransferQueue expansion - Prefer pair-level IDs from expanded preference data during evaluation - Keep raw pair-row compatibility for direct callers and test fixtures - Reject missing pair-level identity instead of using duplicated branch IDs --- # ✅ Tests ## Cover raw and expanded preference schemas - Verify pair IDs are extracted once per pair from both data shapes - Verify expanded data removes raw IDs and preserves branch-level identity separately - Reject data that exposes only branch-level pair IDs --- relax/engine/sft/eval/preference.py | 17 ++++++++++++- relax/engine/sft/eval/runner.py | 3 ++- .../megatron/test_sft_train_data_fields.py | 2 ++ tests/engine/sft/eval/test_preference.py | 24 ++++++++++++++++++- 4 files changed, 43 insertions(+), 3 deletions(-) diff --git a/relax/engine/sft/eval/preference.py b/relax/engine/sft/eval/preference.py index 1fd19b1f7..74eb7ac93 100644 --- a/relax/engine/sft/eval/preference.py +++ b/relax/engine/sft/eval/preference.py @@ -7,6 +7,16 @@ from relax.utils.training.preference_utils import select_packed_sequence_scores +def extract_preference_eval_pair_ids(pair_data: dict) -> list[int]: + """Read one ID per pair from either expanded or raw preference data.""" + pair_ids = pair_data.get("preference_pair_ids") + if pair_ids is None: + pair_ids = pair_data.get("pair_ids") + if pair_ids is None: + raise RuntimeError("preference eval data is missing pair IDs; expected preference_pair_ids or pair_ids") + return [int(value) for value in pair_ids] + + def compute_reward_model_eval_step( logits: torch.Tensor, *, @@ -76,4 +86,9 @@ def finalize_pair_metrics(values: torch.Tensor, *, prefix: str) -> dict[str, flo } -__all__ = ["compute_reward_model_eval_step", "finalize_pair_metrics", "pair_metric_sums"] +__all__ = [ + "compute_reward_model_eval_step", + "extract_preference_eval_pair_ids", + "finalize_pair_metrics", + "pair_metric_sums", +] diff --git a/relax/engine/sft/eval/runner.py b/relax/engine/sft/eval/runner.py index 3e33922e2..218307527 100644 --- a/relax/engine/sft/eval/runner.py +++ b/relax/engine/sft/eval/runner.py @@ -202,6 +202,7 @@ def _run_preference_eval(actor, rollout_id: int) -> None: ) from relax.engine.sft.eval.preference import ( compute_reward_model_eval_step, + extract_preference_eval_pair_ids, finalize_pair_metrics, pair_metric_sums, ) @@ -260,7 +261,7 @@ def _run_preference_eval(actor, rollout_id: int) -> None: "encoded_pair_ids": encoded_ids, } ) - encoded_pair_ids = [int(value) for value in pair_rows["pair_ids"]] + encoded_pair_ids = extract_preference_eval_pair_ids(rollout_data) if args.sft_objective == "dpo": if args.dpo_reference_free: reference_sums = None diff --git a/tests/backends/megatron/test_sft_train_data_fields.py b/tests/backends/megatron/test_sft_train_data_fields.py index e44df2391..a89d9a34d 100644 --- a/tests/backends/megatron/test_sft_train_data_fields.py +++ b/tests/backends/megatron/test_sft_train_data_fields.py @@ -85,7 +85,9 @@ def test_preference_rows_expand_before_generic_rollout_post_processing(monkeypat assert [tensor.tolist() for tensor in rollout_data["tokens"]] == [[1, 2, 3], [1, 4]] assert [tensor.tolist() for tensor in rollout_data["loss_masks"]] == [[0, 1, 1], [0, 1]] + assert "pair_ids" not in rollout_data assert rollout_data["preference_pair_ids"] == [17] + assert rollout_data["preference_branch_pair_ids"] == [17, 17] assert rollout_data["preference_pair_costs"] == [5] diff --git a/tests/engine/sft/eval/test_preference.py b/tests/engine/sft/eval/test_preference.py index eb9201094..4dbcc6fda 100644 --- a/tests/engine/sft/eval/test_preference.py +++ b/tests/engine/sft/eval/test_preference.py @@ -3,7 +3,29 @@ import pytest import torch -from relax.engine.sft.eval.preference import compute_reward_model_eval_step, finalize_pair_metrics, pair_metric_sums +from relax.engine.sft.eval.preference import ( + compute_reward_model_eval_step, + extract_preference_eval_pair_ids, + finalize_pair_metrics, + pair_metric_sums, +) + + +@pytest.mark.parametrize( + ("pair_data", "expected"), + [ + ({"pair_ids": [17, 23]}, [17, 23]), + ({"preference_pair_ids": [17, 23]}, [17, 23]), + ({"pair_ids": [99], "preference_pair_ids": [17]}, [17]), + ], +) +def test_extract_preference_eval_pair_ids_supports_raw_and_expanded_data(pair_data, expected): + assert extract_preference_eval_pair_ids(pair_data) == expected + + +def test_extract_preference_eval_pair_ids_rejects_missing_pair_level_identity(): + with pytest.raises(RuntimeError, match="expected preference_pair_ids or pair_ids"): + extract_preference_eval_pair_ids({"preference_branch_pair_ids": [17, 17]}) def test_reward_model_eval_emits_one_score_per_branch_for_order_restoration(): From 2cc08d73d2d34cc61d560f9596a62e0275964030 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 06:22:58 +0800 Subject: [PATCH 20/25] fix(reward-model): reject HF export MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Reject unsupported reward-model exports - Fail before Serve startup when reward modeling is combined with --save-hf - Direct users to native Megatron checkpoints that preserve the scalar reward head - Keep existing Hugging Face export behavior for DPO and causal SFT --- # ✅ Tests ## Cover export configuration boundaries - Verify reward modeling rejects configured HF export paths - Verify reward modeling without HF export remains valid - Verify DPO and causal SFT continue to accept HF export paths --- relax/engine/sft/runtime.py | 4 ++++ tests/engine/sft/test_preference_runtime.py | 12 ++++++++++++ 2 files changed, 16 insertions(+) diff --git a/relax/engine/sft/runtime.py b/relax/engine/sft/runtime.py index 5307f9fa7..6b2e8b895 100644 --- a/relax/engine/sft/runtime.py +++ b/relax/engine/sft/runtime.py @@ -35,6 +35,10 @@ def validate_preference_args(args: Namespace) -> None: if not is_preference_mode(args): return objective = sft_objective(args) + if objective == "reward_model" and getattr(args, "save_hf", None) is not None: + raise ValueError( + "reward_model v1 does not support --save-hf; use native Megatron checkpoints for RM persistence" + ) if getattr(args, "custom_dataset_class_path", None): raise ValueError("preference objectives do not support --custom-dataset-class") if getattr(args, "multimodal_keys", None) is not None: diff --git a/tests/engine/sft/test_preference_runtime.py b/tests/engine/sft/test_preference_runtime.py index 89c379be2..679c9e9eb 100644 --- a/tests/engine/sft/test_preference_runtime.py +++ b/tests/engine/sft/test_preference_runtime.py @@ -31,6 +31,7 @@ def _args(**overrides) -> Namespace: "hidden_dropout": 0.0, "attention_dropout": 0.0, "sft_predict_interval": None, + "save_hf": None, "eval_interval": None, "dpo_beta": 0.1, "rollout_temperature": 1.0, @@ -99,5 +100,16 @@ def test_reward_model_accepts_hf_load_and_held_out_evaluation(): enable_weights_backuper=False, dpo_reference_repository=None, dpo_reference_revision=None, + save_hf=None, ) ) + + +def test_reward_model_rejects_hf_export(): + with pytest.raises(ValueError, match="reward_model v1 does not support --save-hf"): + validate_preference_args(_args(sft_objective="reward_model", save_hf="/models/rm-{rollout_id}")) + + +def test_dpo_and_causal_sft_keep_hf_export_support(): + validate_preference_args(_args(save_hf="/models/dpo-{rollout_id}")) + validate_preference_args(_args(sft_objective="causal_lm", save_hf="/models/sft-{rollout_id}")) From 226803600a7076608872379312b2826d31bd7375 Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 06:36:32 +0800 Subject: [PATCH 21/25] fix(reward-model): enable Gloo iterator control MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Keep the PR2 recipe compatible with its PR1 base - Enable Gloo process groups required by the preference iterator control plane - Prevent reward-model training from failing preference argument validation after the PR1 rebase --- .../reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh index d2bef6f23..feb6af587 100644 --- a/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh +++ b/scripts/training/reward_modeling/run-qwen3-0.6B-ultrafeedback-1xgpu.sh @@ -45,6 +45,7 @@ ray job submit ${RAY_NO_WAIT:+--no-wait} --address="http://127.0.0.1:8265" \ --num-rollout "${NUM_ROLLOUT:-200}" \ --global-batch-size "${GLOBAL_BATCH_SIZE:-32}" \ --use-dynamic-batch-size \ + --use-gloo-process-groups \ --max-tokens-per-gpu "${MAX_TOKENS_PER_GPU:-8192}" \ --tensor-model-parallel-size 1 \ --pipeline-model-parallel-size 1 \ From b57a1818f2f80d28d0ad650b314eb4d1c82df3aa Mon Sep 17 00:00:00 2001 From: A-Words Date: Mon, 10 Aug 2026 13:08:19 +0800 Subject: [PATCH 22/25] fix(sft): enforce frozen eval probe size MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # 🐛 Bug Fix ## Keep preference eval chunk plans consistent - Validate the frozen 512-pair probe before optional artifact handling - Reject nonconforming eval sets before any TransferQueue partition is pushed - Verify preference packing preserves every expected probe pair --- # ✅ Tests ## Cover evaluation without artifact output - Reject non-512 probes when --save is unset or empty - Allow the frozen 512-pair probe when artifact output is disabled --- relax/components/sft.py | 6 ++++++ relax/engine/sft/eval/acceptance.py | 4 ++-- tests/engine/sft/eval/test_acceptance.py | 11 +++++++++++ 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/relax/components/sft.py b/relax/components/sft.py index 9da572583..6f7806a2b 100644 --- a/relax/components/sft.py +++ b/relax/components/sft.py @@ -435,6 +435,7 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: return if is_preference_mode(self.config): from relax.engine.sft.eval.acceptance import ( + PREFERENCE_PROBE_PAIR_COUNT, preference_eval_chunk_sizes, preference_eval_local_batch_sizes, record_probe_contract, @@ -475,6 +476,11 @@ async def _maybe_produce_eval(self, completed_steps: int) -> None: assert backend_batch is not None row_key = "pair_ids" if is_preference_mode(self.config) else "tokens" n_samples = len(backend_batch[row_key]) + if preference_mode and n_samples != PREFERENCE_PROBE_PAIR_COUNT: + raise RuntimeError( + "preference eval packing must preserve exactly " + f"{PREFERENCE_PROBE_PAIR_COUNT} probe pairs, got {n_samples}" + ) # Drain the current train partition so the eval chunks have the full # TQ capacity to themselves. diff --git a/relax/engine/sft/eval/acceptance.py b/relax/engine/sft/eval/acceptance.py index 846f3c29e..61a9a1a90 100644 --- a/relax/engine/sft/eval/acceptance.py +++ b/relax/engine/sft/eval/acceptance.py @@ -84,6 +84,8 @@ def record_probe_contract( *, expected_pair_count: int = PREFERENCE_PROBE_PAIR_COUNT, ) -> dict[str, Any] | None: + if len(pairs) != expected_pair_count: + raise RuntimeError(f"preference eval requires exactly {expected_pair_count} probe pairs, got {len(pairs)}") directory = artifact_directory(save_path) if directory is None: return None @@ -100,8 +102,6 @@ def record_probe_contract( } for pair in pairs ] - if len(rows) != expected_pair_count: - raise RuntimeError(f"preference eval requires exactly {expected_pair_count} probe pairs, got {len(rows)}") contract = { "objective": objective, "pair_count": len(rows), diff --git a/tests/engine/sft/eval/test_acceptance.py b/tests/engine/sft/eval/test_acceptance.py index 626baf4e8..906550282 100644 --- a/tests/engine/sft/eval/test_acceptance.py +++ b/tests/engine/sft/eval/test_acceptance.py @@ -94,3 +94,14 @@ def test_pair_artifacts_preserve_original_ids_and_require_identical_final_plan(t def test_probe_contract_rejects_any_count_other_than_frozen_512(tmp_path): with pytest.raises(RuntimeError, match="exactly 512 probe pairs"): record_probe_contract(str(tmp_path), "reward_model", 0, [_pair("pair-0", 0)]) + + +@pytest.mark.parametrize("save_path", [None, ""]) +def test_probe_contract_rejects_nonfrozen_count_without_artifact_output(save_path): + with pytest.raises(RuntimeError, match="exactly 512 probe pairs"): + record_probe_contract(save_path, "reward_model", 0, [_pair("pair-0", 0)]) + + +def test_probe_contract_accepts_frozen_count_without_artifact_output(): + pairs = [_pair(f"pair-{index}", index) for index in range(512)] + assert record_probe_contract(None, "reward_model", 0, pairs) is None From 0e0b059eea2d47f733e6fae8f5765a6f14e8b932 Mon Sep 17 00:00:00 2001 From: A-Words Date: Tue, 11 Aug 2026 15:41:28 +0800 Subject: [PATCH 23/25] test(dpo): guard Megatron-only checkpoint import --- tests/backends/megatron/test_dpo_reference_integrity.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/backends/megatron/test_dpo_reference_integrity.py b/tests/backends/megatron/test_dpo_reference_integrity.py index b5022604e..60d71097f 100644 --- a/tests/backends/megatron/test_dpo_reference_integrity.py +++ b/tests/backends/megatron/test_dpo_reference_integrity.py @@ -12,7 +12,6 @@ import pytest import torch -from relax.backends.megatron.checkpoint import is_megatron_checkpoint from relax.backends.megatron.reference_integrity import ( DPOReferenceIdentity, canonical_optimizer_sha256, @@ -25,6 +24,9 @@ def test_megatron_resume_detection_ignores_fresh_output_directory(tmp_path): + pytest.importorskip("megatron.training.checkpointing") + from relax.backends.megatron.checkpoint import is_megatron_checkpoint + output = tmp_path / "run" output.mkdir() (output / "transformer_config.json").write_text("{}", encoding="utf-8") From 633d386105a25d169e15fb71b5cf57a332458e43 Mon Sep 17 00:00:00 2001 From: A-Words Date: Tue, 11 Aug 2026 15:52:48 +0800 Subject: [PATCH 24/25] test(sft): skip Megatron integration without backend --- tests/backends/megatron/test_sft_train_data_fields.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/backends/megatron/test_sft_train_data_fields.py b/tests/backends/megatron/test_sft_train_data_fields.py index 79e00c2af..33dc5d1f0 100644 --- a/tests/backends/megatron/test_sft_train_data_fields.py +++ b/tests/backends/megatron/test_sft_train_data_fields.py @@ -5,6 +5,7 @@ from argparse import Namespace +import pytest import torch @@ -63,6 +64,7 @@ def test_preference_data_fields_keep_pairs_atomic(): def test_preference_rows_expand_before_generic_rollout_post_processing(monkeypatch): + pytest.importorskip("megatron.core") from relax.utils.data import stream_dataloader rollout_data = { From d1b80d1b28f86e2f99874a95480ec2f5a1d87215 Mon Sep 17 00:00:00 2001 From: A-Words Date: Fri, 21 Aug 2026 21:07:02 +0800 Subject: [PATCH 25/25] docs(dpo): link Task 31 evidence bundle --- docs/en/guide/dpo-training.md | 2 +- docs/zh/guide/dpo-training.md | 2 +- .../manifests/task31-ultrafeedback-v1.json | 4935 ----------------- 3 files changed, 2 insertions(+), 4937 deletions(-) delete mode 100644 scripts/data/manifests/task31-ultrafeedback-v1.json diff --git a/docs/en/guide/dpo-training.md b/docs/en/guide/dpo-training.md index d3dacdf01..29a1af12a 100644 --- a/docs/en/guide/dpo-training.md +++ b/docs/en/guide/dpo-training.md @@ -11,7 +11,7 @@ python scripts/data/prepare_ultrafeedback_preferences.py \ --output-dir /data/task31-ultrafeedback ``` -The command creates train/eval JSONL and Parquet files plus `manifest.json`. Compare the generated manifest with the checked-in [`task31-ultrafeedback-v1.json`](../../../scripts/data/manifests/task31-ultrafeedback-v1.json) before training. The manifest fixes the source revision, selected prompt IDs, rejection counts, and output SHA-256 values. Derived dataset files are intentionally not stored in Git. +The command creates train/eval JSONL and Parquet files plus `manifest.json`. For the published Task 31 subset, compare the generated manifest with the [reproducibility evidence bundle](https://github.com/user-attachments/files/31305744/task31-pr1-dpo-evidence-public-v2.tar.gz) before training. The manifest fixes the source revision, selected prompt IDs, rejection counts, and output SHA-256 values. Derived dataset files are intentionally not stored in Git. Each input row contains one complete preference pair: diff --git a/docs/zh/guide/dpo-training.md b/docs/zh/guide/dpo-training.md index 7608d97ad..068e83630 100644 --- a/docs/zh/guide/dpo-training.md +++ b/docs/zh/guide/dpo-training.md @@ -11,7 +11,7 @@ python scripts/data/prepare_ultrafeedback_preferences.py \ --output-dir /data/task31-ultrafeedback ``` -命令会生成 train/eval JSONL、Parquet 以及 `manifest.json`。训练前应将生成结果与仓库中的 [`task31-ultrafeedback-v1.json`](../../../scripts/data/manifests/task31-ultrafeedback-v1.json) 对比。manifest 固定 source revision、选中的 prompt ID、拒绝原因计数和输出文件 SHA-256；派生数据文件本身不提交到 Git。 +命令会生成 train/eval JSONL、Parquet 以及 `manifest.json`。对于已发布的 Task 31 子集，训练前应将生成结果与[可复现性证据包](https://github.com/user-attachments/files/31305744/task31-pr1-dpo-evidence-public-v2.tar.gz)中的 manifest 对比。manifest 固定 source revision、选中的 prompt ID、拒绝原因计数和输出文件 SHA-256；派生数据文件本身不提交到 Git。 每行输入承载一个完整 preference pair： diff --git a/scripts/data/manifests/task31-ultrafeedback-v1.json b/scripts/data/manifests/task31-ultrafeedback-v1.json deleted file mode 100644 index a2f362736..000000000 --- a/scripts/data/manifests/task31-ultrafeedback-v1.json +++ /dev/null @@ -1,4935 +0,0 @@ -{ - "schema_version": 1, - "source": { - "dataset": "HuggingFaceH4/ultrafeedback_binarized", - "revision": "3949bf5f8c17c394422ccfab0c31ea9c20bdeb85" - }, - "selection": { - "algorithm": "sha256(\"task31-ultrafeedback-v1:\" + prompt_id), then first valid rows", - "overlap_count": 0, - "rejections": { - "train": [ - { - "prompt_id": "e0d5c29c0edd76dc914858b042cc7ad284bdd8d1c18d58031d7fadeeb8e7703b", - "source_index": 20867, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "11d6c4bc1cc418a7b4442bc0cac8395177af553c2db0cc85abf92f4b7e9bf483", - "source_index": 24752, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "b595feb9abc1b540a42bb114f9eba8d7081bcc70cc152825dd09132ddc937398", - "source_index": 24953, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "f615c8be47948f2c9b9259258548b21026eab4e50ebbbb09c66755d903ddd38c", - "source_index": 34634, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "b7629fd2f157be5e46b5ae723c1365b822afc0256006bd6223372e7d91cded9d", - "source_index": 40706, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "7adae33b7aebccf88c3bca7e21bf31b98348d83eacbd2601bc4b9799c329a537", - "source_index": 47859, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "a15036007a80e53f0da38479ac96e41e6523dbf42e4a61d4fc086132ead04ea9", - "source_index": 53899, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "99bb0c8259bf735d42012761366691a28574a809c610d35e358a22908b717301", - "source_index": 56843, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "bce3c7a3d96f7b3b456eb3c48cf1a955bfb2d75a899b5cd4eab59ea9c86f5213", - "source_index": 58479, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "2086d798828c3e96980fbac081a41de6fad0ba8639a95a9860805b1a75a47dd6", - "source_index": 58941, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "d7dad88bee4fc3743973607c73560feb664ee9086d85acd9648827363c12f19d", - "source_index": 59772, - "reason_code": "schema", - "reason": "duplicate prompt_id in train_prefs; retained first source occurrence" - }, - { - "prompt_id": "b529d9f22b9e20a2ae86ceb85aab4adefa891c53393c4d96376b9c470a5f20f6", - "source_index": 3049, - "reason_code": "identical", - "reason": "train_prefs[3049] b529d9f22b9e20a2ae86ceb85aab4adefa891c53393c4d96376b9c470a5f20f6 has identical chosen/rejected branches" - }, - { - "prompt_id": "c36f89802b9a6e409f7cb6c6bbbc604fb7e21eed21ded0209e95ab1e02c0d860", - "source_index": 53004, - "reason_code": "identical", - "reason": "train_prefs[53004] c36f89802b9a6e409f7cb6c6bbbc604fb7e21eed21ded0209e95ab1e02c0d860 has identical chosen/rejected branches" - }, - { - "prompt_id": "76d8c6cce268ce52d2b91f8468bd0bd18d6c06191febd7a8209ca32279869c42", - "source_index": 7622, - "reason_code": "identical", - "reason": "train_prefs[7622] 76d8c6cce268ce52d2b91f8468bd0bd18d6c06191febd7a8209ca32279869c42 has identical chosen/rejected branches" - }, - { - "prompt_id": "8cbf4c09a767d8636d4a4524edef6b1a9e22958f1dc18b7a02dc2525eaaa99e7", - "source_index": 22328, - "reason_code": "identical", - "reason": "train_prefs[22328] 8cbf4c09a767d8636d4a4524edef6b1a9e22958f1dc18b7a02dc2525eaaa99e7 has identical chosen/rejected branches" - }, - { - "prompt_id": "16432b9a6418d11883e2f960338e952ef84f9e75d9272e6fb9f4710ee751510f", - "source_index": 31510, - "reason_code": "identical", - "reason": "train_prefs[31510] 16432b9a6418d11883e2f960338e952ef84f9e75d9272e6fb9f4710ee751510f has identical chosen/rejected branches" - }, - { - "prompt_id": "c547355999a455228daeb3240481df1a1aeaecbbcb7cbe2c7443a5ef49ca9d80", - "source_index": 5772, - "reason_code": "identical", - "reason": "train_prefs[5772] c547355999a455228daeb3240481df1a1aeaecbbcb7cbe2c7443a5ef49ca9d80 has identical chosen/rejected branches" - }, - { - "prompt_id": "04fcfcffdaf695a5e565a45d5fbcf0152a2404d7862ebe4a5201e67326601489", - "source_index": 777, - "reason_code": "identical", - "reason": "train_prefs[777] 04fcfcffdaf695a5e565a45d5fbcf0152a2404d7862ebe4a5201e67326601489 has identical chosen/rejected branches" - }, - { - "prompt_id": "25b8aee2ae3e7b1724b688004292f0fdc311de02f73e0665e9602518daf9df26", - "source_index": 5754, - "reason_code": "identical", - "reason": "train_prefs[5754] 25b8aee2ae3e7b1724b688004292f0fdc311de02f73e0665e9602518daf9df26 has identical chosen/rejected branches" - }, - { - "prompt_id": "1db02d009e337a429b40b0664a6284f8a7f08dc4748daeef16bef0a9bd5d7aba", - "source_index": 43539, - "reason_code": "identical", - "reason": "train_prefs[43539] 1db02d009e337a429b40b0664a6284f8a7f08dc4748daeef16bef0a9bd5d7aba has identical chosen/rejected branches" - }, - { - "prompt_id": "2ff4f1a417a8a0d591fd674de4057be32857b155abe153b7c449b7d06b0825f2", - "source_index": 42240, - "reason_code": "identical", - "reason": "train_prefs[42240] 2ff4f1a417a8a0d591fd674de4057be32857b155abe153b7c449b7d06b0825f2 has identical chosen/rejected branches" - }, - { - "prompt_id": "412cb9a3380617aec25f7b6bfcb72639bd7f2b95d7253f1ae16c251fb56c10ad", - "source_index": 17860, - "reason_code": "identical", - "reason": "train_prefs[17860] 412cb9a3380617aec25f7b6bfcb72639bd7f2b95d7253f1ae16c251fb56c10ad has identical chosen/rejected branches" - }, - { - "prompt_id": "32401dc887bd849c5142ad83047e2e08b3a052931912c84ad40f1f2673778073", - "source_index": 14172, - "reason_code": "identical", - "reason": "train_prefs[14172] 32401dc887bd849c5142ad83047e2e08b3a052931912c84ad40f1f2673778073 has identical chosen/rejected branches" - }, - { - "prompt_id": "1eed0101190708dcf85ceab84e172e2ac4fb3410d735f9b46c3c54d419d17a17", - "source_index": 34427, - "reason_code": "identical", - "reason": "train_prefs[34427] 1eed0101190708dcf85ceab84e172e2ac4fb3410d735f9b46c3c54d419d17a17 has identical chosen/rejected branches" - }, - { - "prompt_id": "cceba8a82cbb7af27536a6fc8ef271a3ad241cbb8d33744ccd431268ec4f7b44", - "source_index": 42736, - "reason_code": "identical", - "reason": "train_prefs[42736] cceba8a82cbb7af27536a6fc8ef271a3ad241cbb8d33744ccd431268ec4f7b44 has identical chosen/rejected branches" - }, - { - "prompt_id": "86bf719244d3172e178fc912fe53332772a9e7a73c178029448c095db1c4f3ea", - "source_index": 18838, - "reason_code": "identical", - "reason": "train_prefs[18838] 86bf719244d3172e178fc912fe53332772a9e7a73c178029448c095db1c4f3ea has identical chosen/rejected branches" - }, - { - "prompt_id": "f898f62951a72f0dc258dfe48e55f7576fc0c9a7392a286eeeb031642e573ec2", - "source_index": 47012, - "reason_code": "identical", - "reason": "train_prefs[47012] f898f62951a72f0dc258dfe48e55f7576fc0c9a7392a286eeeb031642e573ec2 has identical chosen/rejected branches" - }, - { - "prompt_id": "201e1580ad7df831ca43c86a5dcfc4dba5e2a0a9a111d884c161002b8c1f9003", - "source_index": 4697, - "reason_code": "identical", - "reason": "train_prefs[4697] 201e1580ad7df831ca43c86a5dcfc4dba5e2a0a9a111d884c161002b8c1f9003 has identical chosen/rejected branches" - }, - { - "prompt_id": "157aaa1fc8f6991010ce3e2b3e702138300b671d369d2bac84dd8d8bfcf90e0c", - "source_index": 23643, - "reason_code": "identical", - "reason": "train_prefs[23643] 157aaa1fc8f6991010ce3e2b3e702138300b671d369d2bac84dd8d8bfcf90e0c has identical chosen/rejected branches" - }, - { - "prompt_id": "921ade505b9cd43dcca36606a210e9d453e9cf84c956b04d3a456cc1e02e4d06", - "source_index": 10792, - "reason_code": "identical", - "reason": "train_prefs[10792] 921ade505b9cd43dcca36606a210e9d453e9cf84c956b04d3a456cc1e02e4d06 has identical chosen/rejected branches" - }, - { - "prompt_id": "b7054e29998d7c71639bef93bf6f4470f945fad2e77b3f5b8225e54118f08093", - "source_index": 3449, - "reason_code": "identical", - "reason": "train_prefs[3449] b7054e29998d7c71639bef93bf6f4470f945fad2e77b3f5b8225e54118f08093 has identical chosen/rejected branches" - }, - { - "prompt_id": "a60b7ee1ad5b7ac8a556a45e14f10a1efc83e931246a7323373f848d4ab2b0b6", - "source_index": 12733, - "reason_code": "identical", - "reason": "train_prefs[12733] a60b7ee1ad5b7ac8a556a45e14f10a1efc83e931246a7323373f848d4ab2b0b6 has identical chosen/rejected branches" - }, - { - "prompt_id": "1d6c3dbf86bf086c16f3093c240ab576c36d195bb01a4d5802029e3f0d7741f9", - "source_index": 550, - "reason_code": "identical", - "reason": "train_prefs[550] 1d6c3dbf86bf086c16f3093c240ab576c36d195bb01a4d5802029e3f0d7741f9 has identical chosen/rejected branches" - }, - { - "prompt_id": "6c50566bf1bec299ba13416025c72a5e648c5bf381314bdbf33ec6c9c650db3b", - "source_index": 31678, - "reason_code": "identical", - "reason": "train_prefs[31678] 6c50566bf1bec299ba13416025c72a5e648c5bf381314bdbf33ec6c9c650db3b has identical chosen/rejected branches" - }, - { - "prompt_id": "aff4fda268493547926e4c37433f3bc2fa2b224ee424241c0df7382866c50bb3", - "source_index": 48282, - "reason_code": "identical", - "reason": "train_prefs[48282] aff4fda268493547926e4c37433f3bc2fa2b224ee424241c0df7382866c50bb3 has identical chosen/rejected branches" - }, - { - "prompt_id": "927e525af2bffb5051c4033705bce8316269db204b199010b18e92c23d2136be", - "source_index": 9687, - "reason_code": "identical", - "reason": "train_prefs[9687] 927e525af2bffb5051c4033705bce8316269db204b199010b18e92c23d2136be has identical chosen/rejected branches" - }, - { - "prompt_id": "9facc8c570fcf678e70fbabebfdc9d83a5c1248ee6c4b6256febc8cee8fca7b8", - "source_index": 3123, - "reason_code": "identical", - "reason": "train_prefs[3123] 9facc8c570fcf678e70fbabebfdc9d83a5c1248ee6c4b6256febc8cee8fca7b8 has identical chosen/rejected branches" - }, - { - "prompt_id": "445425234596b1a264e90e6a59a022719308cca3af9d81a6113630eea960b46c", - "source_index": 11818, - "reason_code": "identical", - "reason": "train_prefs[11818] 445425234596b1a264e90e6a59a022719308cca3af9d81a6113630eea960b46c has identical chosen/rejected branches" - } - ], - "eval": [ - { - "prompt_id": "2bb3ce67227fd80e1ac019d18b44a32c5055eca1265b4d26f1a8dff15a8a104c", - "source_index": 9, - "reason_code": "identical", - "reason": "test_prefs[9] 2bb3ce67227fd80e1ac019d18b44a32c5055eca1265b4d26f1a8dff15a8a104c has identical chosen/rejected branches" - }, - { - "prompt_id": "a28191636d9e42835cbb0a4e8f478ef738a08d54e12f8eb404db48f94f453f9f", - "source_index": 1165, - "reason_code": "identical", - "reason": "test_prefs[1165] a28191636d9e42835cbb0a4e8f478ef738a08d54e12f8eb404db48f94f453f9f has identical chosen/rejected branches" - }, - { - "prompt_id": "21f5d5d038122239cf01baee9857c2906a60b146f41d5c03b7a20be1331a195e", - "source_index": 1561, - "reason_code": "identical", - "reason": "test_prefs[1561] 21f5d5d038122239cf01baee9857c2906a60b146f41d5c03b7a20be1331a195e has identical chosen/rejected branches" - }, - { - "prompt_id": "b49e32630ce6a19e4239b85a84be324d0af2dde3276f2e716df64e6cf76ce6dd", - "source_index": 1907, - "reason_code": "identical", - "reason": "test_prefs[1907] b49e32630ce6a19e4239b85a84be324d0af2dde3276f2e716df64e6cf76ce6dd has identical chosen/rejected branches" - }, - { - "prompt_id": "14f69be4f65cbb5ed352ecedd50a1992fb657f09eed4a128dddadb023637d53a", - "source_index": 282, - "reason_code": "identical", - "reason": "test_prefs[282] 14f69be4f65cbb5ed352ecedd50a1992fb657f09eed4a128dddadb023637d53a has identical chosen/rejected branches" - } - ] - }, - "rejection_counts": { - "train": { - "schema": 11, - "identical": 27, - "post_truncation": 0, - "prompt_mismatch": 0, - "empty_completion": 0, - "oversize": 0 - }, - "eval": { - "schema": 0, - "identical": 5, - "post_truncation": 0, - "prompt_mismatch": 0, - "empty_completion": 0, - "oversize": 0 - } - } - }, - "schema": { - "prompt_id": "string", - "chosen": "list<{role:string,content:string}>", - "rejected": "list<{role:string,content:string}>", - "metadata": "object" - }, - "outputs": { - "train": { - "count": 4096, - "prompt_ids": [ - "7c7105310e40a86f7e22f15380a3f58cbd10c6d38e05aed5e2bc38ff4d5a84c7", - "587722be0b4fc848404673f40c195db6fc5fe59fe2eed2d63fb0de11c331b48c", - "61fec5e5b0f24fca0d915b011c756ea935fe7a09dd6d04238594e23fabf2595f", - "8e550e61009782ca8b2de412fd84ca7d9c8bdfff090cc74b8ebd82008ffd2b43", - "9983eca4193dc79b9db1672e3945ad06eca2ef4a5dd98f384ba0ac1963c71494", - "1e9cc438558e6d2b09d821ed4e810decabd798f21ef9e367735afe2f8be47817", - "75202da83d77fb6d851ada882662d1ecdbfce179d5f780d1c1a7352f84afa12c", - "f86744852e0c80522f0910c2936231000b301ee6d277273a6ba5eb3b08aab81c", - "f13defc62d1b53d988751ba36737feb3990bad65bbc7496d21f71b2b6660fe57", - "cf9d345c9a0138e4f1c1b85b55647b479b38a98a4447d9f14346141676e3693f", - "95c4c02102f069fd1e6fc81a6ac44e06b14fe4a955713980a68e0f2c273e4446", - "254b5575483814583450de2027844cc4a3b2d5a8a749ef018ca5eca6cc98527a", - "a9a17c14f07c34f2db1224da2d668f9433c1bc6a077a8356d126558a13008e7c", - "14260157596b1ebb21f2fb95c942257a21f0ec27f757bbfea0fd1666f6d9b5bd", - "2f9a943dbaf31b0b028185c2344411464bd7e56e34aff7d5e757c091f280a2fe", - "7f2c49f7b56c6a1c0e5e17053ea8760f3ec385280d96f4ddba460d3e6e133636", - "9ed9b2cbd986a859b045a9c7b319f81ecb70f6a7387cc21c51e4b6364290363b", - "3eb6c7b88500a34fa3f151bd84cf4844b4ecb2c411dead407f428d9b6286a7fd", - "a72822bd7dfb48db2a09f3f429c0dd28f360d9ddfba5a6b5e43301ed321c7fb3", - "4f2932a1c71174f2e791f1a1ae72e1f7d401a9a56c4ee0b225d2fc1025926072", - "161e2c55baef98626b177628721ed902698fe602cc770515cc67d4d674e07af2", - "736f26744a2e6fd0fb5e3da906468104311597ca00d0d833a2185b700d043f09", - "7f7471f0810382846d124236d79a24062545eebf5c89c260075fc05e447ac034", - "af3a9a72ad0618a48493f4e5b0a1618b719b0585ba4f1f597695f7aa18c84b9f", - "c38d7b671df06604360da9471f1a70b32cefe26e0a9328bb04fcad9a049b0ff5", - "e60733a16b59ec6c8c7654543201cf042c615efd6833c0eee8745b4cef585dde", - "67707cc5e3cba2dba4c28f58655b5fd863247d671c1515fd58cc3dd6f1353a5e", - "80bad330999847e4a5228a7d9840699bd617ac7a42ae2b8262d6b376b24d2d3a", - "c09880583fdf41e5c63f24e15a5dbac283494162d3f1d7d9fb195ada8c50514a", - "2acf7ddfaba606653c268962d41accf85131caec820262eb9dcb4d26d7e6575d", - "9b3a4884e1d08b502d3e63b30ab1c693c78499d31f2bda5b10ca76bd3ac20276", - "791837eeea7a106a59070eaa92f2c1fd8b6f2c5158d9601fc8b5788180255657", - "f7edebc78b12af9afc8b758f6c5a13cf783f9e8b3bbcb74811758007ae757eac", - "50492f341b4f4ef07dc814a3806266b65814863a2558372cfce2b8653480ffeb", - "3e63b448fc16095b3257239266b05a4a0470283326695a81c81a7530790886c8", - "5dc45cb9ce20867501cca7fa4fdda71d22a8be9ecd93278e4a799ae65b8a711a", - "0b1ac4735c07ae49e8f649827fc2b4f32664eb51df833f28fb2acb4110451cf0", - "4ba3f063a5717f54c222205763c101de051362da8798d4e7be555c3232737218", - "151b9b1a995ed25fc5c25d9f2c2d4990f23c2bc6e34f5c282df93010ccd0a35c", - "b553cd4caada8c0bcb6d6d0245acbc2b011e1e96706b0284df13af809b201fc1", - "4a863997b824051ad0163551277aa83b80e9deba4bd2dfb73106591d685ec23e", - "65193c1dccdc005c4fd6d370b4ca9d3f7a5ef9b3eed826c4f6f70e011f05d712", - "c9fa0ac7e3b1bb0fd04a86a20b43cde4981a98efeec582b9f7ebd72af4c5f894", - "e0f2bc5dbdf8c169fbfad747738997e9358d982853b13faba9bdff0ba455b9a9", - "fd4f6eda8a71cab1ee2457f414acd4b7da81c19c0166e19d99cd2a8a1864da01", - "bb44e53204e087cd07fc779e2191a98db61b261d364562bfd01fc92f45061bf5", - "60d3fa35a2ad4985de2040b2e69fbd1a739e738d12f3e80aea67f52fc35ebe16", - "a246a283d6b47825eba20ab9812e7f9dcc39b8ea9c62311a7434a2cacc6ea68f", - "fcb299bdc5f652b62a85d2c978858822ad26e7e8d5998eeb4211e62c31ae655e", - "d0a6566367f07c3c87ac38b918954854cbff238c360d8e903186e73e5411ec31", - "ae113d002b53804b888243dab4d37308ce66df759479c8a42337b2e7f2956e4f", - "a689733f7da3bd4d3e10ea0bbbf86f574830883b985882f881f42a858011b64a", - "0542ed412ce22c3d777c20f052fd2138dbc4050d462685bb3203c175a1937598", - "06c30ebb780e53ecd3ee0e600ba0f1367754a4ff5da8776f286ae95e39d99e81", - "6be20e298c0f6e353d3c3b6b73c4afe6cef22503bf173edc5820c661e1ce94ee", - "341c88d3a929292b940ea0160230043f6215f5d430a946f7ace44d371c6490c2", - "7b15ffcec72a67543f6732c32cedef0a121385ce0adb27a2b3383c98bcaa61f4", - "14c451118150ed535769219f282e80c9c618d3036bc0dbbfa972fafc21738894", - "bf7f5a9d41124fd99f1a77329931cbcb6e5cc0afa2cb808fe2ff4ea7dd435aa9", - "35dcb596786e301651ed8365383329beb9f286b6e6d893e041038ec74c79e178", - "09354c81961faa9ff6eb4e8566d0b1796f4c331ae37237fe8e6dbb6a5f962600", - "1ee695e0e4bbcd6caa29af1f7afe7730e536d73d59cfd969d95c2d1dfce133a6", - "30bb25f0207b87ea4d2ebfa530142119d571dba3bd691430a812e77aa34ed33f", - "f6787e10836c26416732d8e3054226972a22e81be9ed433d9d7063becce03895", - "e263d7103241af9f76dc7479d105e0af5c08b6921b54318380c5ddda8384612e", - "2a57a86fef0884eb73bb3f00055bff908e9fad13081740b810a5489959b80829", - "cc4dfc42b97ef66ca7bd784e03291d6a5cb7bbe98f23a328bd8d1efe5870aac4", - "0fde786819b3d5b404032cb332b2729c8c37ce88e8196d99927c5d793444f98d", - "b3ee1aec0e62142bafd35261e23bdaeacea6a15cb0b38b0555f850086005da39", - "74418d34534fb1a1a5f7a80b41f93f503261d06f97072abd351179744f9c2bb3", - "8bde411486aa0ddb100f6d299894cbdaca1ea48e1639a31779a97b5526aad3ac", - "3d1918ca323a6275d50249b4e83486df31cf6fe12c311a2933184453e96381f0", - "47a995b8af40de50cda9ce986f01d380d121c78e821b8d9f493997f4966c1299", - "949f4571142b96bde370d874f18fa4765cdfb0bf3129ba9a3c51f795d3b0950d", - "01e4358043c7c611efd9783a08cdd648f0ff2fc3c11a9013b56d574bd215de48", - "f73779261e1a8a60e2aaa73dd2c879b8bb61615917fc198d3868cec64f91c6c0", - "f16fa88dcc645bd22c5ee44833190250ddf5f5f7098e85d14880f35ef55ffeef", - "d08083677213b848707dd91df5afc3f38ae35dab172d8a10413c561c82e13332", - "21923e9bc47ad7c6fbe04c40b3e923fd811b088cd1551aefd2b0cd4e1ddf5b88", - "98b64cd5690ec52b20f4acc07433ffe4aa609ea41c8b7ef993ee4517da772789", - "f710b66221ebb89ab2c8e865348d8b89117d4d9972e773e729f68afa4f8b7db7", - "c64861971fb3189b7acd266bfc1e7f7d58e3bac48f52ea63b1eae18139fc2b2e", - "a15823f4e2b458508b9904a4ac4bf6c0d29e038b463b557515b7ccb3e2c4ca7b", - "1848461113fec50144998b753a5765c4f3464b3c2ba8f65f95ecb356fadfcbc4", - "616158f1214ec4d8d1933e6b757a7eae15ffdb2322af6540150bcd608107e949", - "6d7b19129616c8bca24103f5e0b674ba80b00b0049d5ffc9b4840c4136bf390b", - "e6fa68a894ac3ef70f256eeae6f39f65e3940824e805d59ab994fd2d93604664", - "0eb7f9386272852a40486d1c83d9b7510a7ebdb657411b14a18ce60569ca35a1", - "6aea00608ae3c8e7b427ac2235e0c4a20db3ba89fcdabd6c80b56d280fa43a30", - "ee64241dcb088c0f58effa42464096ffbe504d37808a8a0ffb04b7b052078232", - "810758bd9054af32d971577f45f35c613abaa95068280c408bce7f598401813f", - "c4f3c31dff559a34a2261dddf2c32f4c41ed8a6251fd0e5d81145bb4e451e6ba", - "bf5891473793f5d2eb92111e9fbfdbafcb652f362af0d65fbe4dd43b2431c908", - "3f7930452bc846fed829a95e56a6fd918fb4687ad718dfea28a28be401f643ab", - "b8593779523369d85fd8b389e5d432d106c56e6c0875ec197284f2a8931e9447", - "d7e14588972e40c975fd66683c2cb1e35e5a9ffc9dd8d345f4f50c207aa9095d", - "7d1b47ee09b6d9659b2df77bf83ecdb7d5f7155c0f65ef705af5dd8ac7d946fe", - "3d34780cbd41f2eca6c6faa759ddb74b0d3135a866e7f60522cb57a7fc561e98", - "e1c1ba53e6c25a277536e5d6961bd1b08877880e904189a3878c89d34565cf4b", - "7723b17ea9f06c325dea75c92a450dbff9708e39f09cecf177a257674f46ba84", - "b619a608347df52cde1846566cde4d2c241df438acb9e305808be402412271b5", - "e4b5982e6ed747c31d09ae52a71ad1f3b1d5fd22e3563b3eefa068035fee3df0", - "a07f51328046d68db043697a3086f2388cdba6850affc0f6b64dbed2e6405f46", - "7c9c87d36adc1fd7fd29b1f83775efa38307a3a1b979a6714133e4050a3798a4", - "9567ce610e9428f9fdd00fe8cfe13b616612da826f9b6dae0ba710c026a31cb1", - "b9134494c9b399709a63bb3f563d11bd24a6c2ecf2a2e3c3346950cba7fad3da", - "44fe06d36cb7020b244e78fd957e913ac534e3233c945f7dd9850a89506da8ca", - "3b162aaaa189bae6a51546e1c8db5e3a72617c77a1fe65012ac2d1caf876517c", - "91ee83a49cca80c328c2ac2ae20b8063874520cf314721271da7c30492b9b0a4", - "07b9348499c93271e950029f3c2966b1b3fe1008d84754ab0406945c84e957c9", - "15a61604efd7be636f8b4cbd129f2d2891c685971e1277002d997f9ba6f68a8f", - "5097526a16fbb3f172a84f095058e2c57263ef9d77cf375b7a0bf5e75b20a4c0", - "4a64c2bb3ebb2323a60a2b30c3a96d82e6a6e88370dc5618a5f9c3b19e3edddf", - "ccb1223a401da915180d4225b63b190626f836cf1f301a649ec28c4f0f9f491e", - "f4bf04b33bd399f5cd55fd81793a0c8da9b6ef3596acd9f909a4934f734dcdfb", - "4ffa4779d94dc69db0e53a5f089cdc54b1883b2f426e14361b8bdd40ed3f9e49", - "1b40c1dcd8d3623a8ec886019f534072ca6419c9b06133f290e684d3227156e6", - "e1ccf1a4cb8629fc197516ff28fb82b524e5e44edc38c34376ff95d787f188a6", - "b576cc3f0f17477377147e049b5dee1a5fe8739418f0bf6d7ce58fb020ad04c5", - "3268f6d67c49cfef00a64157d2e63d675157946b113aee3fbcd0eb13056461a8", - "0c5c5a17f4409db135e35e76e4b767aad04e41dd01273ddd3a13061e12219979", - "8241abf9e891d61c2429592f61659c0773ce50fd8e5223996261f00c45b89294", - "e659b1ec4342949f5da5c9e64743bd280234dfae87af50416f3a349bf3a07854", - "699332d0569fbbc3a191e2157c2d29c186010003e5767fc252a28349ab08a06d", - "7e6c3a77b34ad9c97076a2cea14bcee8e29849a74dccf39312d2b892750bc206", - "3047eae1868aba494b19e1a06e1cc388b57b3a8835af9b5d063c410e2f4dcff3", - "f3e7f07b1ae70dfa6318abd54752c981254dd7d0caf759ff4367ed8f2eae93d8", - "016e9657886f0f66d5308dbda0721bc71133bb54d413ccf6c6dce39711520361", - "0507746785ea30f828f50eeda4d04e5f7e921328132e6f0625296081e8e5e995", - "6b434cbc61a560336d98a31bff3b03441a0e933750017543cd82c939794d73c1", - "224b2ebbae97b8d9129b50d3e65a0bf2ff5a6a01852d41a3d86103d28f23c7ca", - "4d198986f5318f1064829361cf10c6e60071145754c6477e6332c041b1fc6ba5", - "6bcf5b0e680e6c472e4c2cb227be9f78bdd192ef563a9a131ed6961d574024df", - "5b1f6d1e3d59275eccd1afb2ee3afe330caba743526ddcbabf0a0a8889d3eef6", - "2c5938307df0f35dfa95443e13bfb702a1d57faaa36f14a44ac284c3b58cbc5b", - "97e9d0c22de40c5123b9a70a5c099dfe5a23b18bb949864f880fc61fff6eccb5", - "ae5ace24064ac1995d79169852219427f215037a060138e7bd3f6e514c82bf64", - "a9528e9073b1a56bff3d1dd795c371eac8e69895a1b0ceb54c971933aed48022", - "1316d1438284c3b74b4d6acb42574c6cafa15d4a0505a7089f54e995cbdcbc61", - "158089622d8e1a09c4caa6f94534870d9ad8973cb68620f105d924f87f34c80d", - "b57bee7675313e5aea8714e7d3f08ddfacfff652fbb12ca2bf6d436ed1b09d2c", - "2fd92337e849cbb087367568031d35eaf384e9bcfb4927c4a1f1a97eca3aa803", - "332648dde35b3e55bf5660b88a9ed25feb979931bcefc7722ce426f703ff5718", - "0b5298a364440b9a150312c857dd077949034fac34ed4ecc69afdb8ce40a81f1", - "de433cdfbfe6befffb1982e599133c1ced7ad7d80b25b674d2a523d272cd76fb", - "0d40c2f8eb4bc17c11966bec324b49d6c59a628f0ee06d22ff142efedab2a285", - "2e7ee273e7ed85d88e98999ed1cc94e066d5ef08790f83072e009003b4584208", - "82e3f30c6dd8acfe396b10a6f501e28cc0ecddd54670c2e87301366b6c56d52c", - "b6f7aab052d159d45df6dc5a26e0ceee0932017fd421a7bf2432f316b2fb5cf7", - "855fa69be14315e1e99925bbe2d4d792279889b00ecc9b929e417f319526a3e6", - "196193e14b6978a29eb99c25f885c7f2b5fc8717582064f02ddf043cff9627e3", - "4d1bfa9cdbb1e8b076da712276021ee0e105b5809febaec21c427e3dbbac88fb", - "3deb8d19ccc993127328e1d44db7bac3365880a1f5cba5dc26ce2dc96e19eb7e", - "fc4b50091758bcb1106f33f32f7b96e86a9105e076db6b4c5964e22a2566a569", - "25b004c08b1b0f063d8352754a70ca870afcf0d4e6821807ff55f346844d4c83", - "6c5c21946be86c2b9d91e7d61347a6a0426378be39f53e39be2165a54efb3e4d", - "9fffa8349494047c5228f600b89d18b4e8eff557f785a78eca44e3cddd5601c8", - "8b3d737c8fc4400950571059613a270d21a8cbdc1a6de3c16bec2e7a6132d9cf", - "fc8c3300b5dc9ffbf0b8d07a8b9085734acf963bc246a8d6798849a15beb8425", - "26d8e108b39ee40a5f067028507ee5d82926fce23483b18b62ef24af6652d04f", - "92c18a135a4c7fec4528b3b4db5143b528015f689f1028a6a0083430f2fcf53a", - "b526a0f142d6ab28c33071375ca403ac2acaff82b07176f408bb59abfe0e7776", - "1c5e4c38bae002525a2866cf1de637d8243f2137ac3a325e0daf338c2e78c65b", - "7e7348c71675c9fd1d9a25abbe60f757a4a6aa381095cb76e3e5101b41ee4631", - "b57403314c67a853d04b80c66dd7084c20bbcdb564c20742cc31613c18ec0254", - "3ccb452c14d9af0b27ddd54d9b887002389a53e1a77be2ff8627d87e6a340a80", - "efb7914d387a84af466805f13aad1cc24ed43405ed6197e518d99a3f21331add", - "69f9d86cae40529ee787bcbbb9d0909670a99607475d57421f9636a84628fd14", - "1c7f7f217dae6ae33940fab8c7622404729e1839310dabd9c1f3a1b2b9e08abe", - "a645d5c9731c33726cc243c86abb065bf8dde833721e449c78a1b538cb3797a5", - "fa9cb6419efdf1a5e996fd048f02bf5d4bf67387b2b765329d23a0615df25d58", - "57a6018c00a89115f3d955d9b916e5c99ff87875653df3b645143ebf74c4a0b3", - "43c97af4afa4800ebadb93d8d1bde3f0f6bd1b013b5f8cafb5a6e1993222fd4f", - "789bba698641e563743bd52a7aa94372216bfa5251a6a3f1ce31be563d3d7ecd", - "c3a05b78c001623ac6a8fb1e8c357283001181c2a8e530f68c00648b6453b8f5", - "980936f5db0b77e860fe86b33997dae1a5d6b0c7f76108df73c65763162d146b", - "b740c8215268925a09d22e02c268a7e7098a6910f0d009abc73ce171bb52bc77", - "9497ac7a18fbdcea713d104b764e12d1cff188c46f3c92d57614da1b2648b024", - "3a55b7161285563826f79b4748b851b5765a246c6f6c9dfa564be18f52a58848", - "6deb624b2c9d526989ab36fa6f30719c979e7dbe3053d17b858c816bcc3a78f2", - "9490f3810403c8c3c92f2374aa3bd575d34f4aea667ee9a18dac17e884c6e2d2", - "c9004dd028ad614b7b72f02e72e685c06ec6e7f003aa5c903262527f59c7da47", - "fc4b9afe0d2d538ed7c8f949ca985d83eb36d6e012d653a637ece34719d0759e", - "39be9d9a53971e42294c04213cb5e0570d53af22e5112b075dd9216018621247", - "74ee16dc4daca37605bf7bc6e2c98f17619d88148f532c0804fb32285c71ee73", - "790d358ed205278ae9929e11a4d3b93fe336d3c702b4fecfc51866f4398f824c", - "42f356743e093d5ce36c9df88f1b0ae17c1506a19497a6808989964c2cdc4a53", - "945352c92420d79d846a50ef0e83d8c74cd4bc2fa8bba8d568face14069dc2c7", - "12739cef019d6ce849b478adde8acb2432b78bfaf0ea28ba30cac5024c606802", - "c42ea329ed78e0cf8e609011ca354d67e069386d7457874b4121e7cc704c06bb", - "91636ebf271adbd2d12150d272bf807cb3daecb42bd33592fb25d99a30aa2958", - "e4d6dd932c617866dd65fbb23655ad51e7a14e20d333bef0e7455d371f7b8569", - "c9a686ccd69833534d4a8c569d7f5bc2b6c2d2d18294e74338568c89d2b74de6", - "657ae0885ea75c53a98171dd21469a2a0c7c34fe6296cb47981ecb971cfaafd7", - "1f743e55136bce8a20b02d3566930209d725a7de408967a3d6b2b89c37c1f75d", - "db07a03776a6d54b1480002ca42cd5af48d3d4766bc675246999e0c51a3d7e5a", - "a0ced228cc95a728458c28a99884527848e48adf88012faa019480c9975d43fe", - "f5f116ad0b33926c4a0866853cea2152423a8d66c3843b7f4eddbed76f614a01", - "ceb2b40b3b769f184997d2e716e9910ea22a4aee85abd19ffc9867d531bd648d", - "7fb2a849df65e37542c7b1fe91297b0c8cd0efb7569280cc39eb68e19d386ea7", - "869192471bfac0c0be9c22c924474fd05711eeb72e4b4d3d096a72ae5a790355", - "7a31cb46babd5dd92b23ae7125fffa12528d2c0ccaa9d869d867ace747f2058e", - "29545efe39825c4023ef90aa1e6d4701b4511c32d7df51a3472a9e67b22e7788", - "3eb8d93e1390e710d539bd825ed17707724c339627509c26464607ad515e1569", - "70b653a722cf7909fa37fa677c287bb0ab8bc867030d87fe0da57ab42b71abec", - "1c547577c73d3ad9a6b214e8523e58c94c24c9defd50d3758ed99f9310b7dfc0", - "686b7b9eb0da1359855c46a91c2b8f591420eb5096e9f1a20edc4c07755a829c", - "edb2aa7753514f43603a3a7c57fb57f045c73ca2c9d5386a2b1f9d7cf4f366d6", - "41794f9ab241ec4a618f8081d9086ce0e3ce8a5fb37b6f210b69e3bab95729a9", - "084591e3f824d19f72a099b1b3b5cf9d944dd3e5c79a2c3ad35dd8b933c83c66", - "a17c1fe12ee03d373ec629cf5f5abeabb0a863f48503bf53483e97a6259a2fae", - "e1815e0fd2ef228576923331edf07564244ea0ef4ec8a9bce411089a77eb9e4a", - "72aac98e4ea4f230c7e17e26687594f09b9ba851430a2374bc86764cafe81cd5", - "b99fafcddb32ce7c664da0d03696cc7609f162f7ff5708fd8ef90ea029381012", - "2ad0dae9c73b6bab181f9ba583cd6135e36f1ede5c70256c76d0c325e23146a8", - "61578e1eb9bd641c12755d97eac9e03580103fee88abb89ab8d8fcb0d033403a", - "57029f8251c174f542a65a78b955563b100839e13e19ecadb16380c7f722ddfa", - "e2eb0590457d8d3b2485f18eb17eda42b66c5df55a8412d8e41043ac18ea2dcd", - "a6828f4846da4f8d28d0d70c4c21d0b942c048640e7a917aac873467477bf790", - "f0c69b7397779c42ec3f4ac766d40fcc1850715b45282ec65c0f3f7501210b2b", - "a46842d32afb26f4672710f6bf96bb3eb1e5502e44f9b6296afc1e0beeb3acd6", - "159856c0de30e3910b03fb44d19ad3226d02eb3b4d5e14e0cf0101f97a3a39e7", - "0e9f8d59f5c594ccb09d244bb31d44fadd6f868f7b8ee75d271cc872b9e3e39c", - "3dc05652d05f197571fb21788807caa8ba8f3bd139e2fe378f534cd6c1fa1b1c", - "9c4df7324b364e19828fd539ec135fa65641a0a14de901ff01ebdd8fef5e9f15", - "f83682909c66c58d4215068019992c1a026d717721dfbbf289e19cb25021f218", - "489e86d2b6142f6649d4663e41cf52db8a33eab12f6d1879ee04b18421b72a46", - "00162ba49e949c3eed146a8e5963138cda61cd5022600dc6d68b8b1db7a02416", - "7d60422b434cb295c77f760e49058c962bde3cbcba8d4e8b3bf309f1ef369006", - "6ed9bbced8a05aa65d8f89f44d49c16fb6e20d335f542fa7bdf0011534d16696", - "eda6374cc7e5962a9a970b9d212ea793326939ccb1301589511c599849f0d85d", - "d335c315e02c76d05ea9c54ae912748cebe93687f95211aab083b9ccc580afee", - "83e693b0a50ff26577ba5d3b6fd0d0ae9237d4a5eddf3cc51d4f9045e2a96a79", - "af5c8f04cdd95b7e307968f2dfe82201ec10c9325cd7c8d83a9d0b84b070d898", - "a01f8f06acfd16e25ef796cd8f11cd296db02e9ba711f3607f9fd19955b0c5dd", - "c706d7860a3432668bcab9f847788ddafdcb0d2ff31557d1d0b057e5e6be7864", - "9c3b035f031fc23b3167122b50e99773a6e0ce8c09a542f4243d5e2aabbd9119", - "305785162ec6e0738525913d8cef9d699afaefa1c2cef0ba1fc11bae4f554fab", - "06cf8e24e731c30ba10680d5d9bb7891d0d6e48d89f210cf3924def078823b5a", - "1eb3ab0a9a234aefea51ad0b8ae2f42ba1a3baa6252bdf08b1a34aeeec02b9f0", - "06f8164a25a933c76fc3dcceb1dd3cd84fa1e66764f221a05e4fa114af7f8ead", - "b49e582f787bc647241c3315bde80d0ded85811d7e6770a79ef4b7f243647826", - "9dedaf79fde1c10e03f44b0ddb51cd1bc58556f15dd6d91ee29408c12ee2d8aa", - "50434eb3e3aae009aeb7f92478f048d49dd74da4e099ea9f63549720139df64a", - "246c8773b410663c6f8027aae12f8cb8b212ccb2c2a200d670d2d69ddd3e78e0", - "68815f914c9b8adb7e5737a16babef1d013a677ba712fc96902fa23b04865e7b", - "37321e04c0d0271d7b1daef8047cc7dc55748b494677ffe9c19e96189353d52a", - "6ea3f4a89c1cc827cae360b4950685dfdcaa7a9486705590f05564f7231d595b", - "9344bc409727ba6b23d356ae2f7dc3f117225dd2d53c45e0845367a648378ce3", - "e1dc913bf608df1726e6920994e363798aae8fba10e9f271a9b713b8979d1834", - "3182acf08ba74d32d1ab9e7c1c0040aa18fa264d00cf5d89fd75c5f0eb50cacf", - "6f14765bc693017178ee7209b8d750cf91c7237864a0e165aa4a862d07e342db", - "1dd3ecd5e9c89f3cd4f23e71961978df77012224e05945ab4ff424676779759f", - "2012fd3b77a72509f38d8ac3412858f5d624be6ed4b2ea109b1500ded829ee1e", - "312dc602ead1d36b3847da1b1044e6c278d4800c33394fcb32f1bdaaf5133953", - "b4e46c41c493b16feb1b343baadfd84cbdf43832e33584f2933e0d673d5fca09", - "2bad92f2082da0d55c78b21f8b598249d78fc8e2852d06bcfb844a335103c540", - "6e6c09e690fd8baafea05f26ae3ea0d94835414e0b5f1edd32e4ca69562aa6c3", - "df677b292bc2e238fa2a7a3c8e66bda5805f05d82b46df79cf2d06931d6f763b", - "4da2f6ab93a4b6ebe6517a6bcae083ef1f4b6250addacdbc2b1679e2d5f1aff8", - "d1b329c59ba588effd8a7f618f9105ebdc3af199eb915558da9d7588459d290b", - "45b14485ccefbdb3aa14ebb954398759ccc3c6ca77e2ceb2dbffbbfbee2f946e", - "9fef4fa70b52ba95cfc3c9f527c78620ed39a8ee53ee4e694c64c070bac0771d", - "498010666f2be38ea8619213b1aa6620c84f3bb11416258b2fa77775a252da30", - "6914b091acd0352122eb350898c1dbea11f6248284da6e0a5c8e119cc241b036", - "acdae4cde1995e86fd1c9eda474659debd5fac11e66e851df4ea94543a131191", - "9b29979c3023ef59dc98d14cd8c19692bdc43cb39e34e148c5be92f2b0e1f6ca", - "b86e7ca73eb5c26592d38820f2709b7b5f515cd45c1692ec639c84ab00d7512b", - "f7d3a87c04ba4cae6eea3490a6ddee5ff590ab0666499743e4c736c82e0e116d", - "6429246dec081247bf5cab1eb8b28eff026bc51066b4f458f78c84e411124131", - "23013f27b84bb77a5a17c20a8a4e3f4a9f35725e7d3109bff77626b180d2a84a", - "d7dfd8e240aad69dc57e66b9df5e70f766fd80d19b5ff56e6b0929e2f8b4be0f", - "4e4681e4ab68d2b190fa416fb91329fa80eea243da03d997048cb646e02462d0", - "561109a16f1e6e4111e2bbed9076e99aab872b359b78812e8ff57807033f856e", - "c6e558213ce810e0ca56234a183e79fbd22b4cb8fac0265d69163c1e2277841d", - "740dc6a89ecbd4596b8c0fe59e751ba61cc8f782eaf50b5d4fa738bb104f1419", - "00dbcef563d23ad78177cedc64f4f3e5a0a5fa757bd81017bc537aa89c2f6ae9", - "0ef88528b3eee48d323a0abbd48e00a08cd7083c003622008d72fa9697b24d04", - "939c7b9d8e42b3717d20a8c5979aeae2f0af7e28bc9870732849eb54c8d4396b", - "3c48fe263b6d9e22dd747e0b54699544b3c556be305b1c411d8e41172cfdefff", - "260086e1b8ba006706ea5dc0e5caadda32a0479bf7f9836efd176d6548d09cce", - "edfee900b0767f665f5ebd8b40bf7e7d35959031ad647df8f93554c9bf152a42", - "75928df7c86a68923576a7cd6b38def4f39180b3567be4ad28fadeb8be0a4c6d", - "51d60d419a4d066ea9e6a79bb8e95283597f0bf34975b44f2d954891d1d6789d", - "d2c4496ccf48577b0d2cce11376b2a9e3d7b2dd62993fdf7f739843c25db76c8", - "5793f672c05810d786d4b3a8e46d059c75f6e5a464938e9bf4f7e93c57e3665b", - "adf2e799962416cf98c49959adf35f172ae03e352052a2702d5e2b4f0125a91f", - "a80bb7f440e907e27d8ed3effe5ad116f076712f81b575e2223f56fd646e34d1", - "4fce3135c8c4f1c8194b753e3fa16e48a8ef0a472262cc1d21eef141bec3472b", - "9567ecc9ae20a6544aadd44127b85cb02d7e917c426b659efe0c81be34d29258", - "d815d01b3c77f22d454335444692f26e086b0d2c764a5e47678f55c1a5e287a6", - "1c08cd6011d234cd52964b95ce5744225d43a55f77355c13ce2f3228a251a0b2", - "f3e1851812989f72bbc1441f720011492e5e978b941e5dc3642d6253320b49ec", - "5d3cea043b6131f59f98c878cec2d77439981bd673bb048e7a0f90215475b4dc", - "eb3ba6f1b30df8b1537ab3197de91583553bd1feb5ac5ef30efdd4f269bd20fc", - "6c46485554e49adcdc290ed5085859098b74863a114eca7052c3ab182ee587df", - "f9c63032d65bd98e5af902250105db034421f960df34567083a43ec823d0280d", - "8cb1cdee5515224ec3b70fa59b61fa7e84fdb9889eaaf70544e841aeb3bebff2", - "3da558bb1f1a694de16400cd255a0a09b12898a4827eabb3d0406f732a983528", - "52e0fb26be1193a3f1a04a9accece26881e93ac4bad4ff0a624e51b739f90847", - "7a3c75f7f55fd722a01ce54f8895b8a38b27bdab38e8382eab8defaa284830b8", - "3f64e3a6fe4a9a8f347b15b230bd546ead1b23b128aa38e7271c3a81a1206b5e", - "1fd5a7862b3d2b6d3c80294c5d3168149665023323e537e97bd21e0c0df6002d", - "b617d0fd6bf932503080eb542d8c6d06d5d990aa885ec6781cb2f7d33d5d36d8", - "eb1510d01e8539cae068b9f14d75b21f93132626b9592de2f3ea57c206a967fd", - "867f68920b4b18d31870e179649a73722051b8c4da2139c64c7e1b7c5843987b", - "3915d135c60df007c86282636663908d31eab986f8fa17a97ec1af5a0816d55f", - "e121a9c0aa0fa88d3ea6967d641745d9209d73309faf40747ae2990dddd740a2", - "4dacefd6fca83b1a8497931a471753af171f676b411846a3b514bbecf526174a", - "9d73b62347b0f6e4e05bec188686009427d75bb7f80c5aa0972e62122c2b015b", - "b334b9da9c0d8340c6154693fc3704aab07d815e519560ddb8d852323b825d89", - "3294017e9427509e190790e6bd1e7a0ee53b7aa13b183e81525e2fdb7b70f126", - "2f62eb67b2beeb72b10fc5d240f3f683f4b2c00e81facb76bb413b97b7500c23", - "9cdcf3c9f26d06d5d639e30fe87493b0bd76d5608e15d6e21398d1fa80bb0f71", - "aaad7b13f22a3eacdb3a65e95f4ebf77c18bab65860d47fc10d1b48873b9fd60", - "00e9c7ac58c303705b6dd5f85584d799ffb5e5c803b0bc4c77f4f7632ebd30a4", - "088d7923148a8d27659d527ab2fe330d81c1b508c9dae5467852bbc2a773ee61", - "f8056e4341cc05b2a65733beaa92080b9134cacd5846bc7c422407a0272f6551", - "4fff5c9b07b5846c9972060bda68b86cf731d4e505ad70cf7c682300de0954e3", - "af55bf02069ac7949263f5ba52df4c2ca7cc5ec70ef300e2b37e8671040c01e4", - "d9dd9e9ff1ed7a52e298611fe45326faee86e51db6e35a87fbe08ced995fcbbe", - "838e0ea082a1187a0515fd628bc3ffa9c4602ff80a73c43cac47e04335933b21", - "62dbae58b80eb817bb8200ac2c96883e7cc54407132a17814e01e596470aac5b", - "323300aa2734d595aba82c351bc208d5e911941e34ea24191775e8a85e4c5285", - "a60534ee3fdee27713c4e027d9ce022f55ecbffc2c5f5f8b5b326f480c0fac66", - "aac33119879de4bf5118793fbc2e250699d880dba0e7391403383f61b1a9e81a", - "4b73d5a36b32038fa31d473a7cd7af50659cbc8429f5e06b9521124b88e98f35", - "06de075ac6aa3722326d763f388846a9e1c90805445d1891ea1893c9e33014de", - "22f81e2e02bf858c0856073c3520a327f69ebf7794125aeb93627838bbaea833", - "70baef40f87ff6f508438bf9100cbd337834429c71e8c3135ef8c0375804b5c2", - "066da2a54650c744e4cd46ab888456722395c3fca099a3d730e563cf88e50d19", - "4dbb624f161ef3a4c85624cc6bcae9c80ad9bf99734abe86214f77d4afbb9464", - "96797c6a3d952a4dfb0e9ba2f8697cd9ea62722f296d02e36b7a3ce070deb342", - "19eee0fae2162a913fa8bd8dc0eccbec5441c1473368040851280dc5090ee828", - "acfde0f759f55630e11090fdb28cf5d01c5ef6050d61597a87f38fc532c86089", - "47c84bf3ccb2cec1fc96209eb1ad2ed008b1cda047fee87aa5428b26b0fd13cd", - "bec1fedacb1c84f60d2dbef6b8661c54579120761268a261d7f6bb058d679c31", - "5a8e307323d28faa017e3809b6ec5065b7ec4d910da88b99044a40bbfa39d0ac", - "7af0801a9852a3565a125444478dee9026065d754337f5f891903836383f34c6", - "3659dea4cd4157f1ead3cdad0f2af872d379775e90553febf7c42dad621b2b86", - "05482d081fc3b436138ba4d230679fe34bf9c3208134c5cab0a7c9962128eea6", - "8508fb326e1f8f40479c9371b72c9e835d1eeed753b486c56fc192b5b50282fa", - "b2b989d0f1ed40fe32dc91126ae15e6b9e26305a3180a2705099344506df25ea", - "dd46d268080d4ffa7d33510a7338197406afdb7adbc17d18a61ed17b46ad8556", - "0750e644b6ea955e8be4cf1234698012e680b76b7306890935c8e3d65786bddd", - "3004753c2a371837ff211af8df26830a2d930d4d2604b93ddc8fbc0019feccd9", - "8f3a7db8ff6e611b552fda768e96e5b3ac81c96867664330219fa2f40724b28c", - "874189986c30ca95e952f97e9b3bedcdeadff743c2b1eb36eba89c3d502ec051", - "66d8a0339e59c942dbd3e3e346fddd0a2d749ab11a87741bf764aae0c0e4576c", - "0de29ce5eb458a963a44d6fa48b43d2cca19a57f3201ecfecbe85ef4dba94b28", - "bbee1b1470ae52c350b8bf15ac84bb03d1a81ce9d5eb77e0ace4ada01f6caa14", - "b0d7ab6bcc0a2eff7f87514f92994b6689f010e993e434633cd222ce1652e07e", - "08ede6db36c4ba6f412ab6d00a436d94c829bdcb16ae3cff4ff8bf6c8f7875e8", - "ac4a9ac69fb2cd89bee04a3c049d41898f36ae04bea1d329ebcc9c18140bb4ff", - "e06a6e2ad8288ba63c158c24c41da0bd0d3b4e45f50f9e79424e0ddd2ee60ebc", - "33a1cadbc35a95a082af3ed264f3fdcd717d437278bcb9f2977768bafeb3dab1", - "7ca0101f81ee45db4608051bb8b0910b209feef5b1886ecaaf77e0a4a583114a", - "5ca9764dc2a27dc03c053e6269ddeee12f2d7460e9182121a8680a0299b53cc4", - "32edbbe7aa35684cf04c3867003a53c68c47765fbe97244e8111261907606799", - "cfc86e6a1dd6ac5431770c4cdc5d5a2fc6ae274be847c6a6c8abc01f2f0ea67f", - "543ae72368ed5911b90f5939b565a508ad316eea2d4cfa34fde4af8c9ede63a5", - "bb73053b66e643eac2dc36cabb384da84dbf008e91b114ed696acea43649f6a4", - "915cf23a528f1fd992aa3210c39a6d35a2cbf544e681da62ce2d9a74cdccd8ec", - "e5608f5f7ae24d3657ec296c33146f84d08d912f068449b6a32e01c14bffc2c4", - "203fc9949b147b6f01fddaef31b841569d5e5c674f22f53f2def667810ae47cb", - "46075f1255fb80a7ed2104e8b72a3c1eff5cb0c6cfc33fc7d10727e33c211551", - "e53b47dba5d2bf854ffbec567520ea2b2e2b3c5fc631e2451a5584491a5a7d14", - "26da8015775de3bbab4bbe81db93e814df8564e132a28915dfdb2348ec9365ac", - "66b455829f3074c37870193601d6bad894e393a5bb055a494b50ebc4d205cbc6", - "db14ba3d0c01d09f1e7998f8912efd3eb2b2d3d5552b7ea7781c6effc1101089", - "44dcd734bfc0d1c868e366775f52a2360a4c86287ae7354821fb16eef6e329b4", - "3fbb397e0effa2ad5dbdf6ad3035ad91758b5e8a292a656f0579e86edfd9e24a", - "e3e6c944793ec65db1f8c6dc65980489bbd23eb3ab45ebf528fa9a584a0a33b8", - "4687f239cffb847dafbc3a754fb279e940e519144f3e175cab5df4fdef5ca34b", - "c31c28379bda8a94e51a1c2fbd36cb0fad794e39fb78e723f81509276bfbd0b5", - "2c884db2a3b284f0f69ae374cf1869d596fb0241974d4aa8cba9b1bc59508ae1", - "6f43b182d98e138ab206cbc71c33906e76f67c6aaa4657716867f91598f17bed", - "56bb1d89c05268d2887488cd565fd257e0bc1157dda54e6a4062af3fc53e8923", - "763861f075143eec76eebb18e87be38d7a4458fad2d7c625316aeeb8a663e4ef", - "4b4790ede8173a7a653b8b61639f4086fe6eabe982b73d337ad0fce0d0d54a4f", - "a9ebb44c6303391a66b596f11cef7065c53616f4612e60fc34a539d84ea71d44", - "727ff6f3f354d6250bfe121965d4b0a48e00ccc8c8a5ce89d4884dc888b19401", - "6fd2f69444a71fd4e2e2fd233befd173b98ba5e34e0f2325dc25ab9330758796", - "f6010ae0031d586e81ff7322397bafde58685941a43c4d0a29d7d069750a41e0", - "9a89d8858f114b83cad0d7c907d3e8a2fbee35abe78c260d127337a7bb609e66", - "e4113e93a09e30eb4419f5235b4255b0c4b01d2243c191fff6c8c57672a863de", - "6db0770cfe26a5c7a1c8ecabac51c7609aeab4647ebb523ad41a4f26c90a7d00", - "b42d9268732cb3922fdca4f83bcaf90319b0016e6f80e18dbbe0e16ca953837d", - "61c8740f326fba12f8f51a9cd743f03f01393eaa95b4ca6e08089d531fe1b7b8", - "e35613bbfb7abcc24bfc967c08cfa3417767640c80f422540dcb7b1382d080f5", - "a7cea9373e1454c944f3b8216dc5bc94731ca9534a01538165e08699b187c68e", - "bb04f412124c81422e9992d1a66e3157a12765f466ac1b3790b42fcce9f0f547", - "f0b6f0d9703bf7885716e6602d03500597d6aac3bf6e625e6ddebc77ac0a1b54", - "b259fb34e0c795ce32020d6afbbbf37fe2b3be64f7c4bf42812c0aad4c4eb786", - "3dcb4ca8dc8ae62f06ddb517a457111c3956c962d5a5b8c314e0401afacf87cd", - "9e1a60482db1b99617604532f40451d02192e273d4a856bb45ebaf83aba1fc55", - "b008e1e5457dca9798f69c859ba4b3e3996870a5e9d6f6a8a6216327e672625e", - "2e48c3ddd5c1e6a72d8a50a7f30e44d2fe81e0b7facd751fb90808803dbbaa99", - "2bc0d53142968c6992fc0c0e2c76da016245213252448b4efa1e9bef47217eec", - "cf7c30ceed022ef3e92e73f7c17f866a6230a92bee53d732dfbd521428a0a9f0", - "fdb0ffb8e4e629085c870e9dbec3b8fcd769d5b12466366e488b2ddbd55f6478", - "ceaf45080007a75e258696a8b0169a3a7ce9ad7ceea386b47ad2485eb2ff45d8", - "6e892b9996690095e32588fc9e199b3b18e7dca1edb7dcb784cf677d1707c6aa", - "1f34aded433b84d6d9c29a59639abdfbf14374f59974b24195be1003845d736e", - "a6e542cfdcf34d089e02d7d9bed207c0ed7b3823d837b3cce3292e9be26fc7af", - "666f996832b0c5657521c4fb17c974196852a46373f69b205e02876d2a7f4b3c", - "6b7470907b5547d4fe740535d2930e816ae396d86ea232bac70063ceb516d79e", - "925d48117e08f6f34627cbb25036a66ac83c9cfcac629cb24edf5b003fca4c49", - "71062a303fd5bc9a9dfd3e6da076250a24ebbbf9c51d7b186e6f6f9ecc5e749d", - "56aaf846d9c83ccc22f26bc05d40b971e02b67ebd3cb40864bcfb2d32b0bf41a", - "b660208941a4c092c07173f7790784e88f8ef130a4ab41a9ebcab762af4a0ea9", - "31f9f40db6f3832632ffc466b6f434062ff923b986ebbeee42f53426ae87a873", - "c391a67e84581e90cb4a43b619cc7850ccc759e864d78ed69c2bebd98dc9eca2", - "f5cfe3625b4ab9bf36f23bab346f98347466e48760ff7a6f0ee2eec0ccbffb23", - "928e113c1e118b6e892acc5425583c76d901af3bdc0ee3300959b9320a65ed93", - "d18d08e6dc3e5862f6aaa6c76f859ac00da82d05609b44f40c2556ff600b9186", - "98c1d5e453e293afbba640bb7e504cbcb140b7a8d49925f831b0b8df75d6a4bf", - "7147cbac667843625d0fba7551aa76eb6dab3334ddc684bc2de0e52ce3ab760e", - "0866575c45d93a913ebf327db9f75254b291646f52c13dbb3c1ed2a2e357ebdc", - "49cf006d5c99cbeb602ec9dc173303ec9926733d7b2d58e8c72c66b825772978", - "4e080638d950c5f612cfcc83503c436bffe56612e3e4bde88d87fc1753237c29", - "7b2cbe55e35e876f4236f4eccf3c30e3900e38d333c11cfc1f6c29dc959b4578", - "be3a7bd0ec54801880250af66f9eda2d539acfc19ddfd5940ed602b617e5503a", - "85a95b82fd6ae653673da6d36aa39a96339aba15f2f403925505d6904b696277", - "cd1f8a38950545062a80966c84732d4293f5e7b04b4ea257a74c2fd64a86d533", - "7b9eb84d78cf0cd4dd574bc3b7bc79eed63998b724f32d90c72ca92eb6a43e2c", - "7b5f8aaacb463e91b335cc6d22ef06499e5e33bbc1a23d3ead7cbb78e41b8adb", - "a02edd640655c6ec916eb3a6b423fc29c13e7a4ec5904c661381b59aa1c78089", - "92320d47ced011a0af9d12f8001e7cf585380438b9aa1a8baacaaffcc36dcd02", - "1cce9975daf6d0039bb6c9d3898eb4c12452d18956cb9f28af592945de094a56", - "5f0ed3cfd78bc493e2619eff1d807c0b3693c513117c2ac4040ff347a3ce99d5", - "dffe4d0e7656c17b55fcdf565de3cafe1514680029d7ffb9237cd994403b77e0", - "e6265d372d455500b92f7982a5833aea6d1899b9896b9aeb63c19a1ba8fd4960", - "34f87165937447c544cd557a54d05280fdafc3cb3dc7f8cdaa606a78a256e3a9", - "78f81cefaeb402c5d02cf5d897a83122973ac2d8a1e8280f157ac59b4284be5b", - "b30d93c81f4cba02fad61e61fabd743ba86013774503c4e4d59768bc9524dd51", - "ff89d819ca5c60a9cfa5d45e3b79c155db7e3199496de36862b51dfc50507ebc", - "237b8eafcbb45e08ec8d4673dbe568215ff4021739c8031fb378c041bd11f0e9", - "971722cfdac2836bcf693fa73c03cbfd5b1ffba50756c943766fced21dda29db", - "ee25f31d06bd44cd174ab7ddbb52d12ac4fbd74dcbebcf810b82b130bc67ac63", - "7f9b39655d856a5444e23da087ce60b24a67777f99d6b07a05b0435c0336952c", - "4255b28c2c8435ac486ffe9a79daeb8f2dc40ee6b83a6c9fe42d2f3d4909e457", - "b592eb6ba2ce0f7c6ddc8ce6c8c6020883b3291971f8504fd3c34b7c3e7e1c31", - "d2e12f12d456397c845b588d605e9f144a7a7ba2cd445eab5adca8f8d9cc0483", - "aca0991996713f03e4ce6a06a198b3b92d267ce0aee2b6e4ab54abe9ad0dcb96", - "1297bdfe9d37f2838921556cb726bcd7934c18b3ac2c2c75b903bef129c22ef8", - "fa670be9e5623e394726dbcce5355daafaa75232b55fd5b4b38062005dff31fc", - "643e0681f3d327a1b70cd6a182cffdffb62e1f24c0cd33795687fa302028a469", - "a6dbb725523894df87b7017f579e19ab5eee299f4b0219a2f231495f0d8e1668", - "d39690ed704eb61de1c307ef6fd04520d65652975d5191f1ea0f03c6f1878cbe", - "861ae253383c26e28dbcc175f7b56e15ddaa9b6d19a5789aaf614f0ab644811b", - "812e05aa44360d189b91d05fefff92cf2dc6244b5892368d225648d0d3069336", - "ec3598e77ddc47e941ba8c5a1955767f4650fed5740a1548a9f3f05f8a5c08dd", - "010b6a9b53c29ff335a8fb79997c5580a30824291125a52b12af29df8d9dca33", - "7fa482e9acc1661a5e479a37925837c77b1adae1656330e84c72304eacfcf2e9", - "b653ce0c80cdfe7c0d9b1c451dd1f9c70dbf8709480e16a64652ef33ce245f75", - "9423ff12cbca9acdd2b92cbb1be2191d58a828746b9855a62a279eeef7e7e013", - "17024ecea5a4543d3a842239d4dbdca588c963d0d9ee2fcba2d6ef8e1961c642", - "f83de5e58679a9babed4c0e6f57c3689fc6445a72f39bc9d2e8272d7e615679a", - "2acb5cd30d165e9bb11b8618d42bd53d52bd33c65551b3a3010571af15e41c01", - "00821369258ace38acf540c35b8c318f43d4c22f0f121cf00c2a2818ca5e4d58", - "b6938375aa7f577ad107ecc3781f578c8cefcf0358017d3429ef0078bd5b257c", - "cd57589ad5ac01d653957a42dcea8fccb5eaae55f1ed1ecd8482d5580966b873", - "647eca2b733716b659378aafe9a8169df84cb90321aedc6f983ddc5916186d7f", - "2998ba3158dbe60aff2b16d9c1d24e4ef69db4ceac594e566d40e8041f79d24a", - "da8d24703bdde2ffe7b1de38cfba389067b6e57d810e9c6140cf35d0a259ba2a", - "cc815136f95a9b347915512202784f51233a5e096746b013dcbc8b41164e84b7", - "12b6a194bd2d225ca452ba81fce874a79cc6ae11bfca4c73f8919abfc7fd8880", - "952c1fda13e6d01a0f72514fa7db899b8c11b50a401bb25bc6c209df0d95875c", - "50592d9edc8f4d17de0fd287488ccd7eb4eba43606cff411c4d9ca904b237aee", - "86a730b047add0b17e2cd61ec04bbcb979fbfc6b74557c704fecdb7caed8a09f", - "9442b6482e88b5b7a5ffa5941cd4d3fb4d091f5b288daa6979606c8df8c261c9", - "1602d2ca8568854d37f40f4021c07a7ab41157b26da970b591f08b50afefe629", - "a629f05567d107e8473ca3fd98a950d50a76dcfce8d2da6b54d3546758c76020", - "d342fd86852d1251485788a4c660abcb97fd633a626bc2edf30d11dae217c7a0", - "ccd23db89308864a51a4670a396483ae3bf6268b9c6093102ea64288779926aa", - "6d3b4b3295be5dc3336b61bb76e6747aaa342dda8be9d46ef2b56527bebbf08a", - "d05fc7e6bd4b946fe6ef3b0540e8de604af73215ea7c06d8af27fe57fec02fb4", - "1501ea28f6c165f620e3126cd15b077fc029338313e843726f02ae9e303ae4c4", - "bd87e3adc7b4f0910a2e1cd9943264a02aa83f4e7cf2e18df9fd8f8a81a975d6", - "e02ee46e6f9bf227b79f490821add7c8da82673ead28b185a25e4719702af2b1", - "d462388680d59bff84b0db2dc3bded66a71bcfc598cbc82d1a323089d63e56c3", - "b5065b35ff0268c7f95ec7b5ddd5d07a053bd8114249b5d1d20c7ed7e1804d3f", - "9ed266b5a5a9553a8db35e2d5100e132a59e9cbe0ec515a790e947d1e58ebfb4", - "4929ed38ed61217868d40d6479b5f9017228fcef89c707cc16a6b8018568c34f", - "93638073e650346208523ff4deaba51fae621bf0683a30e1ac7f2e5445a2fbb1", - "1758530d111589b21a8175a3296008472c97b07241f7f0043cc6de6d1758cced", - "db3857da9fe8eeeec6352cf52de39ecad752438fc0de9507eb560594777a190f", - "3a183c447bfa1f20b332b705344095684b548240737d639fe1fea4715458a76d", - "45df318ccb2ab8b5a7b099d9e9c278bf8312c502c5f9ef4cfb872953ab796d54", - "83ae57ebd775193bf7c002f0ce8f70af1a85d3d5022ecef8ec7e0bae0eea123c", - "2b00b819b1b1c1a590662cc54aa13fdc6983da3b4935587c118ca48845a3b5b6", - "9a0b5d191aede4147af667dd40c80826ae5fc54a7c48cdc44c31747ca3296933", - "2b2825271461e8798d4cb34bfc1c1d65ca814fa1bde2760e0e3eda20ab95b73b", - "7422bdbff0d22966bc53d1e5ff4656fda5d3a3ecfb39bf184c1ffb57d20d0eb6", - "989ce45f84524611e8c643ae061ca7f730f136f8cbd23a953d479d7794311217", - "15d1abd43618854d90adee34a2a32897771eb05be2b8603804d336cb0dd1920f", - "a1f0ad6e92094428c69d2accfab1db663d61f1c33a7835ce55c4b1802d684199", - "c13b78297ae2bd046bce2b2884723a219be101d91016be20ef55a2231304d8da", - "61184d04f45bb122a75bc2c8ef814b1fb44f89493debd6d9085132d944776b8d", - "7999ac8c01d39ba8ac794947f62a9e050941f562894bb6b14ac79a0ec0341e8e", - "ec457e4b14ba2bf19655e008675d275269d7354dcbdf4c5c200a7fa0d10d36ed", - "da472e5886923f9f553ad274489477211cf7917ba8d1555ff992a1447d5e2171", - "c435daced3159c8a3890d63b4a81bddb1346695d6e505f891c891a82b1cb58b8", - "0482dc5957ed487930c7d4ab2720130b4aa15d701d165f1222810e5b76a6b5aa", - "ba73b24a4678505711f655fa94a1dd6082d703206c0674125087640f4d9f529a", - "f43bf9a4719d2bc39c125b379ac80a419e50cd1f380d1d331973f3d0f2d5ac16", - "a6647a45d342bdefd877b441336d1a6d0411c441540c7b5d69159a3232a802bb", - "1493964d28a3ef0fe42db523ee9892fd6dacc1b926c8315804bb47a09a7306e2", - "ca7f0f1a47319616ed4978165a28c3829cb17d70b510c17e1f41443dc16680ca", - "5bd625e77a57f9c65fea28e5247ffea15680a3295c2732e2fb36e19d1be844e4", - "528e3e113396106e9b2a3fe46a9103ffd99c6d0dc2d178ae7f778e15dd293f6a", - "bdc284a42fb39e89b0c4cfce5a0ea2d3872ae65e04f8ad7585c088aa6aa750c5", - "b900ba3fae9ca7059c2892a2f4e2a0e909c25e3b5938ca2497dac9e314eb0ab3", - "c48f02ad2bec6c3084d77082040ca4edbbd360414b0e9c1cdadb8a4d01f91b5d", - "7a65ba1c6d3b041f589e854572b1c3dbc89b9e1b569359f484c5fcf6b00bd663", - "0bff43fbb4c53a446f25d197283094fecdd9993ed7ab4c8512d28699fa38b8a2", - "8cf98efb7fcad27025d99c0ed6d1b947d0cf5c994ebfae98dbeb3a0cf4626f2a", - "8237b0de08067413a98ba1f254bae056d5125fd3978eca25952440d205aec2ed", - "16ae6a142c84f780f2d064d82f0186e8d410a95a8681a0a94610dafb1c561e1e", - "a5bcb8059ac0eb5cd9f47bc351a071cf99f1366ca1c485b7517e95c9556d728d", - "06a6dbe913f6aed53d130e58c59b3fa0cb1718b8aa9451fa8d32edc4c699a7bd", - "cbfcbc64cdba6b9f404ac5adaf021534a3ab91e033cbfe8639f30256fe6bea1f", - "b902d8ea9c7c20315f9db7e698a816f40aa459f2755f4d3af7e8ea7de4d0557d", - "d30928e494848ecc15e3c998c43e564b8d9ea879ee8a50d3e41e55dad824d6a5", - "dcc5fe2fd47c6f76a58a3ceaf96a349f3ee43db33d1c48aa4703e85255f795c4", - "accf76abfff8f217efbe47759fe4351b6a62cd2e2dc098f13d402ca7b67b183c", - "2f0228f03efdafa1c00a1251865532577da6f7c266cad9f0ef5a45d0a1929673", - "c3904e530fc34637a79e2d102151041e9f091f6caa84f504653818cbc25ba040", - "95bb7476bbb5ecdfe68181d57227215f034b2f498ebd50a6b99bb2fcc8d2295b", - "6c8595db98d2af62bdedf5a6abbb8d620b85588cf65a5478b1b5eb15577e99f1", - "c36d237a03680ef6bf986914a9056c1cd0b92aec05916d36ae706cf3f36693d0", - "c73de97cc2b8c5978ca5c9b7ee66e653ed26c19dd15710485b1054034bac5699", - "e8d810a563f12b4f071eb9b2bba562931be60d1986ce68a729216ab6b74178bb", - "1b5278f5a2acf030acb17f8ed16c4cf826dca8f7d8c686dd38bddf1bb3cafd60", - "d24fdabb2b04496361dcdf51102fe402e4213ea5e36e8e3b592471b88c2c32f3", - "97e8f80e5808f243df21b07463615fa371e68247e1cb473065e62e3c068c5212", - "34e84541020c912397baef48920f1ae0aae22f24ed317e6693573013ac19d25e", - "d2e41ffb405f69da54a8a9c6b1fb460e300d4042a72ee7fe61ed576da3466a4c", - "4391aeb09cfbf23b49460e9832c6057bf3c92721f2fc8b97fdf5da4407ebe693", - "58a0fb1b13d6e4894e24ad3d4d6576532ef8187a0f8d4d2d018a70ca95e2384a", - "9790d23f4a06fdf6ea3ba361303d7d6b715e9942de398f8e977365f387705c2a", - "b41657652bd6e9b81e3d136e4e3c89fa774cbe49837cb158901eab99e347b482", - "99712a0d86c6d8fb44f5b8cbe8d1a7d79660801f904b00cc34309956b1b8458c", - "03f1a1f10fe04856e48df4148e1b4dc3750d1378633cb83743a3b42ff892827e", - "10d70c22d69acceabfe40633de59d1cc00ee13e1c22582fd6d9d1db53dd3bf78", - "d95907c4cbd3f6804000e74a3c8b4cd4b21eb50a786ff7859d72252c700eb247", - "7077d0a4054c682e6c9911408dc1cae9e0b822a03eab201e3a46d925f3f3d594", - "4b4aada1ff18a664b0f49ddb7fd8a5b8f4adfab2907f7d61a7465be32a5e54c3", - "e375b6b14f3533ef717546eb9f9da1f10af2912ee9f469b187771b3fbe3ec81d", - "c2a8f246993e62d036c0ada6e7cc43240ae5fb2d111025caf59ab56359572bb5", - "5bda8715b848d80f46cbe4d4281247740f47847baaeada5901c372fca372f253", - "69150e416f10cd6c6f529e7afaa4158d74d0339ae59695f70141452489588520", - "62e69cba01ea7ed2f71d4f7229842f4152a615e4e6d1e0ec9f4489a0286fc959", - "8135c52d6fab239272881a757b8583aa04fa1043a96e7a84a08e86f72306ad89", - "df6aee4219dce6f1141839a79a43b40e160528b73b4c530aaeeaf04d507cc5ad", - "6c005b42733524040d6ff1ed8edf287e01c59d4b8c22155f7517eb60bbd0cf90", - "a372d2f884874be7213a268b65db2f18b473f1840e745bbe32bbb954dca1c4f9", - "75c06361f2b4d2ca7827591eb7e1608919d3cd7b52fe3054d072c60ed80a35e8", - "25012aeb6197c4877070b274be59200d768263b34e8a1f685982ad2a2988c4fa", - "8048c1c1a4f2abd395fc36c44a828e306829b80c79e427187c0820ae48f1f906", - "c675a9c35e57a8041cf6ee745f52f37a9553a832c99917007ddf95229ed7db98", - "755035766a5aa8f4b8a143c3db1350e634c1ac34b022d572228712f7ddf59961", - "3a9d981c542bf5d1dc5976c3b11588cb4453de25fbd12029532240a9911c66da", - "084cd917c80b09afa96d3fa53dd89d70e0169354d1be9d99689c737dd57b77d1", - "3159e3d922b80a4ad1c071ac1e1db52fe436a5706651b4b85c1f4138f5c2b9ce", - "9ab1e375afbf7535f1ec0b52017a2b3c41b2dda978d639c654531d9560e34766", - "4fc7a595f0107f4d78d93e2bce0701c3e63a32403b650e0ab79dee865ebda95b", - "e37bd5acbd0549ca15c05b8ea5d3f3dcb7b1732dc96121b5617b6d811b9548a8", - "cf114025629d19ae6442ea6fdbb1a7bbacf2cc1aa3e93c0e43993c3c3cb81a06", - "ebbd63a0fe03c48a9f4c35707f341ee944066e1dd38021dfe2e49e4eb1e1cbad", - "c9f70d69503a9c1f9804e73d6d391d1aa5388ce4608435a6cbd0b047cbeb0a52", - "560d146c3e69683e15aa81de396a33a215f9bc19d6f765a7bf24e7261f91dd23", - "39c3082013dbed001d1a9e8cc43fb2eca964e92798eb600cda4d025f7070bed0", - "002f3b7c4aee398b57c524d349f97cc75cbea2684757ae11b8c5ee830dc0e14a", - "bcfa9ad8147616ea419b8abcfb9d7fce5bda27969bf837177406d550b24a1abf", - "931a91f282fed8dcae42e19422119c99dec1f34d6c6405cd31c49cc24df12468", - "8d527696ec5159cadf3bc30a76038391029b283e3fd1296308f9c0c640bafa3b", - "cbdb1ec707d5fc8ba2249c19930c5ec5134c8f342bfd677656b36faf1337e806", - "a3f36b1eafd8084d24b1fb56d8a54bd28c6d5f366abe3b2ce6fee66010101ea5", - "3b07be3b0074ca7a7254e83d05d7b1f523e93151bd8ddbc5f2ddac4d0ecec529", - "82b898f1f4974764e22651c2a1319697f94ebc3353c5cbd5c2c8cfa670dfb6a8", - "47ebc96350bf7a431f3fd589e46dbc068a66a1c7049be7a6d1ba80c287dbf143", - "7d6aed761887ad6dc4321ce35a9b6af9c2f06c394c4272ce694dbba4dd91be4a", - "07a316dd5bddb77ef66a259e974b173402aa3fa7f4fc4368ac3924f9f4b5af76", - "09b84b6bb21df3e936e7650054eed14ea41e1216f47fe58f75a9e5eef95c585d", - "a8365eb7122060a0257ae601e559a6228254d368fc0b0bcf72a70499ecdc96fb", - "3d4f1dc78eeb8f2fa985696e7df984c8a4f77dc567c66676b903778e0f60503d", - "f5e1e8bfafddba24707e6e363f8f8f1ccd18bbfbda2e06285e1bd31fa219be7c", - "f1091d96b18e2783efa174d0d6bc0ed9e10af5d58779bd2e635b6fff23091ffc", - "b3aa44b81de24219933c63111bd024e9bbfb73c910e1233fab476fdd9bea8e0a", - "f6848e25467dca2720265131e43fc90e0e4a9cd647954499043ea133af27decd", - "cd3c984711a188288b7351030d18813f0dadd657cb2c26524ef2407b057afd70", - "b52a2334f7ea44fdefa04abf2289a325d4f67effc8eb8503c48296da23050f39", - "6bc9ef1c3967828fc51dccdde293f77e46e893f8151438f2cea67db51d3a9d0c", - "df783833bf6b31ea1d49ce0b76216118f2b8adaeda81a227c8b36edd1b292a95", - "0f50bac15f728ae3d57bf5fcf66c3d7339ffcdbdf976af3491e6da8e949beff0", - "0f4c0408a4d9e2147d51a53bf11374ea400d326ae748c1ecc1fc6e408d6ef139", - "52db906fe1a18efa2375199ccb93320051d806734f7dd5e64791f2525d7cb3e0", - "ca8a9f16672764855018ec0cb110e53fb8496f21dbb46f6e58ed82a8f5311362", - "787dbb4046c2671466d722fd4bc88bd0e13606df32d52ee2c7d39d144214776e", - "a135a92275dba1a875c7cd3b20fe891b8437aed7e8943a1a304834d6a925a0ab", - "c8c404c86b294a4d3ba6810d9974e5017f2bb78c5f3629487f91f9c2f7f4ca6d", - "7484a61be38ac945d7ed44e00e92958d50fc71b68bc9576e647e0c4dcc783289", - "4fa13165a8a4ff33148bef30544b85cd2620255424570fb6e1b7de2b22dd2e26", - "55a4d3a594b260e615dd6d0833f2a40398d45f95de592e36c82273990e9eb667", - "3e763fd113ec9556c0f6f88ed7f5a0e3bac8c276adc5a5c2a87d444d397c03bd", - "14e631fa0511757bf429e821ff45e99168671bccfeb75cdfa9a7fa094f6b42fc", - "bd5b45b3f6af949bad2ae367ceee99ebb8e4a336fc6ded47e4fbb487fc60aa59", - "53691c111abb58ed27d15bb37fe0980d43fc7c3bb7affee8ddc91b6bfab973f2", - "aa1f9d7dd42eb5abda099d7309c0f9ac49d9f26e24607cac39aca2c4ea82be56", - "4da6ffbebee278fb496ef23f64b5f6446639700cf1d7cac8795f40706c6f3933", - "e04b8abd408ef5552ffc09b3cdf63bc93f5227684270776848d9dbb0a25dbe00", - "b831adf8f5309c75a39eeead9d957b205f517f90dfe3ccd8fd48fcbf256aedc6", - "cb43dc64da7b44ca72cee82c9686d489cd8010b0951e5d218c2b0d75b335a2fa", - "460faebdb7b5cba7fce52def7312b6086c1700a97f234d471a0d2ef6416a46ea", - "372b4db303cfd6aef22819d3079156a945d352a430267b86e1bc4037310175fa", - "5712356ac5c15a018d35a34364a313007491de68499f2136fc1c5960600a08ac", - "1b5fc2444dd6fb13bc1ab556e9efbb7af8d779c0eff33bb0c442cc8ef9304216", - "68a0d4b44d74f6281c681b4d4449326c45218f9041a039b5ac213fa3ebcec8ec", - "36bac390aeb2d3374709501ba28fc529ddc1f3dcbf3a015a69e1cef2cdb69d27", - "a0ade37e695e451e13a74ac7b71ab61f23d2e94a494097c2ef89e454ac889c92", - "b7c4952cb5644e2b1f4a292591c09343766286ee61a0e6492362c9c4bec38c82", - "47326094fd8330cc41a9306ac749a16800c3553284f2bc4014fe34dfc492ec5e", - "53d12200174681aa130d45009b330d6e1d3db0b4c984ea636c82fbe52cdb9913", - "7d175bb98dcb4ff39c92552b50b6e1a424f7f7c3883de2f478fd8a81203770b9", - "ebf1cafa32b4b02d69e92052116e0a9b2000f134c65cf22378bf6e5b9bd4bc7c", - "cec6bf10677fb5f14703428fbecdda72872ce50281d105b3492e86178ea99454", - "e233b2fc0844d80a6091cd7d268f99054232498c1ebbfc2e48ef6a07bfdb64b7", - "7011ff9333f96fc0e91e225d7335da6f49352fca06a0d541adcc86d2cbac1905", - "f80dab0f20b98e0832faaa510f2284a3e8486c74751a6e365588537d85c49951", - "e087cb183f4f7db7d23a959a5e6c07e4af107f53153a710dc56ea6f07a9ec9a6", - "c08415bff7d216da72754a85b280958d00ccb8c77390afd4d6ada3266ca861f5", - "b737baee84aaad2d7b5ae831fa385f55645b87c86fb6b1c855b57ac2abb57cd7", - "140bd85fb6675f759114670ab7ef209a96dd8e33deab90558dd66514a67ce8ea", - "71f36c67fc7d4e0447923e925fb33cf0e94345212393519697773ce5b9b60783", - "e4f496b0ff450c02df989d917e42452961ddf7a3beec6e08c8175d3c7f800a73", - "c34b128c25c4fc9a014c5f97bb865ceb39b3afba0d7dbbcea43249fd869bd202", - "da1b91e04de8789998b3e4c4c1a24a9479e084e20ff3d53eeead2d84d190e344", - "bc9a3edf7639831a60100f3e8bf92ff701102d7a2f26f5db9146d961ff1c572b", - "4d35613dc046819ef9d6e7b795ccf6677468a397e9d72c3699258868849b298f", - "f8c548f37df8270d6aeafa7837c71c8b1100eafc369adee67950858dc46eb140", - "8009b05c2888cde93909d361ab83f803fbe917bcf9cc5752a0aaceea03c66f71", - "e17efbddcd33c1fd285fdbd686b95e5b8033a107f40ba76927520fd5b5006174", - "bad2eeeedeab90fdff504e5c9994cf23d41575e331df5a3a607703b18ec4863e", - "5bf299a1f09e49f8ba67f4ecad39842f7c71099b6062b491d47df8454d06eeb7", - "d03ba799d4913d7007ce922ffe1914a59735d941e45f4a6420a41a29d91ea331", - "6c64e4920cc274d21bc1814dedb71bf1334b20fc5b48f72a7f7b8179184e9524", - "84cf3be5ae26feb0b201b664c1042087c15104b17ba3c3c309fb1f8e40605044", - "a47b87a9276a4f8f9ae11cb8a6cd0a641828057c5a4dea003cc0094af1268519", - "8a8406c58fd3b95b10762d6fc58510976fa718bd05f6d1c7a004ca5ccd371e1b", - "f69d38e5d6e3781bb5fb9a08132ebce9d21f57057977313525b736f557f45d27", - "f73ba64eeaa7b0c2714191e7ae503e09700f664292334fddbb2fcf591f5dda30", - "323b92340879c3cc3d0cf4c2e007c24036de150b6b6a797a26f915e12a187676", - "1ad588f5feee63a6ea75824da65a547e88d8a24feb2e374f5c93e2b4d24c50c2", - "33948272ea977373a191d13a7c48b79b1c35a078b0efead88511432a09278f3d", - "1ae4dc481c12ead8e5b0361046eb3f8a9b96f250df4f4c478d3c356b49053d98", - "cec0d004e66fc45f4d37791e24afe998118865e9cc086139a00497156a81bc2f", - "2a8cef4e60b799eb7899999115e3a307686e6fe48c4ba39f56b0da01f4ab9539", - "f9cae4603cd29e13be78b1d15f78313445f03b0964ba6629620b15b8c96c0373", - "ea2f024a51d8933e545457c9f28e7c31bb9ea9453e8a015701091e7b87ddd40c", - "5e0c98264830ab6421047902b5ceea9e88a737700de39e30fa32c34e7aaa0c82", - "2b191e069fae2f8b5ca970f00f20d34654d9d465d2d5b262c793baa641906c4d", - "cc3c7d1d5cdef9e68cb85588ed724ab5fc2226f35a5cc5dd5b0cc730d4151f6e", - "ec3b057d645025845c62a1d3d70366333741bd5417f072dfa5696bedd5c8528e", - "14f9d6d2d6a98019cc1c3402f0330a47976e512902d8c350029b52c6b8972d9c", - "6ed60f73644bb2d1f71b04697d324ff366e76289a4b8f2c0414ac3ed74b14210", - "ab9b1119784334919897db50c94e1cbdf5a844902da4661df9d8feb65a8431c6", - "11887b66c827589195b17c0b717c691089f5b6bfb6f97c09b8cc71e054bb742c", - "98cc4e4d8159f5c79b514e6e712e88b81270d6eeef9f5a2c92bf7f8bff95a8d7", - "5e5024b5aad9a133fa0ed11c6fcecd45d7b0007bec29005110ddff11acc9effa", - "d6955dca5e65bc49a62030b50d1dabb3aea223f644b6e529de7c76b6dde53288", - "1ce1e7d69a5e8e6cc361cd8c5c11424ee1ccc0c5f364f6fda39c5f07b0cf36ed", - "d3b9a68153f427564407d55fc3840a263c1617434bcd5bf61454c37d4ab7b545", - "183aef0d814c38c257b1de28c3bff93f7b006bb120c6a89aeb59b2d4061cdff6", - "71ffc609b110534253be7eec76f92df9d1e9ac69ce7d07f98b312e7a9b70d1e0", - "605db5449ee7770694aad2c426fd2381fc66faf4686c0e990e24dd2f1b8e7ad4", - "e4425f305f9d6b1c96e91c9e265d6b3bd287324d0c8c5a48d12fadb5862cb145", - "c998bdb4b1ee8017cf2d69ae995806be9d3a60daaa184a1d3c7780577a3309d2", - "635b6d455ed09180604403d965622cbc9c47e720160b98784ab9b217a5fc6aef", - "9b9d67892731ad1c075889c3237f45a5a3305820c3de3f57b434b18974696d0a", - "6793d4feb816c9f5c8a8dd604e87243445e57983af7dfa7f54393b7612fafd30", - "c14593eb65b6c61eab181cf8a46a1ff4c52442126ea6a37eb870f940b77d14b6", - "69904f0513423c9a03482645b4af4fc683008f4c1224a6504a2fc1e37543aac8", - "c555fdcdd776940580faea8b64aeb7b8df19c8850e68909cf8853fc33602f899", - "cfbfa61cfc3556fc4b171a7e5e2a4029952937b4705b99a19a78e0c0ef293e1f", - "28e2afd985c2ad24debd6c65ba514231689b6ab9a44e2d8d70ab7bf68c177e7b", - "9b36e8d63659cfa15a209c3cff000ddb7bb855875553cdb80b14c7a84b2ed9ae", - "d9ac1b8254461997aab756bf171c4f7e41dd75847cc233b677a3fd8d0ca00295", - "e4ae312493f0d8345be42668647aa54e83dd320e6084105919121ca7e59053fd", - "717ed6af50d4b6da729e7b4129c38409da7f525f2a0ddec050643bce2263de6f", - "497036d61d8928b7117642a5847c98f3740db1e76780cce7596653ccbe39b52e", - "04eb76e068f9f1c330179cb58a3b322459823ed1481ec4b76711e6431aa8d40c", - "f320488a2752f4911da641eeee0064da1e87886fef5a2cdc0e8722815c300acd", - "ab72a67ba77dae89b3b5840dce5d93e3d38528586cd33e0836c912e2676a3b67", - "5946c839e512f33289845533e546dd09f321c09c907148cd35c9803f6f9286b4", - "e8d8134cd794364e69e3470e58c5075c72d52befccf7d4a735dfac7a15f1a930", - "21d6a56b2ff6c599a68f87793a530f78966c5b1b1b384377b0f2d1e4455af1a5", - "28ca0b5b0c936c1b05850e30f8de470acc2136b15fabbe6961ff7ee34051be3e", - "fa7a36f844c00378903e0f9bc5b1a77ef3b6241c868772dffa6a8a1a25e86f47", - "a00523f71cb4af9b40b0f9262762182ab876449ef9a42cf7fa0c4d1f2d59e452", - "76df6cf6827ef3e4ce089c86a324be3156f87e0a2d5a13600b88917de9f498bf", - "e86bd8509ad97745316f74db57fe9a78edae2a5b13f8a4643158c1f7e29bf400", - "ede8106745da6735fb3024c95bab56dff664e14120677775fd5621c517b47bf1", - "f4801fa73c6de9e5f03c981f70824bce510a5bb3ced622f22c11b55479350350", - "210cc001daea91c7753f4bb52ccd790774b0b424396549a74952d40df21d964c", - "6b7fadb461cd2b514b766dc2f6639111f22bcb528beb5889eb85a868470257cc", - "cfb6e9bf4f52ca2d56107663efa486f0087ffb590f42d6c8567a042a6ac4513b", - "f2571c9d8f33a09796f5a29134d3aacb6728f6d5dd425c450c0560e94df16945", - "8ae2d9715a468160ff2ba57a7b7e170603ce0f0f1fa8bf9d848e23ef6143cb8a", - "0e92a47bf931279dd9460ba9ac9b74d07b14c0f39d9a6805e1c37aa72b077068", - "123b3f6f2dafa1616d788cb2a62378b9df4e9e0889bbf29d8ac5898b26464d79", - "32d59d1abeff80266624c2cf0dd3a467392bce70c80f4c675530fbdbfb5c71de", - "5447be33d027ddde1b7014cdbb5e22d6528b048f38b96f43ace514947192bc5f", - "663bce7335b23e560c1e82632be43791077f9136f225dc80705cce337ac42acb", - "9bd4f5a2bd8d02f576f157f9aec9e6726d4de78f9ca4a5b8de16466a4aa5651b", - "866b7e827b334e310636abe8292672e60587b450c2dfd7c459ddb5340fe9d4e1", - "3998ccb78330acafc87ab7742e5b20ec452f5b0144eb4674920f8396dacab092", - "51526a7f2924498dfdded52cf25a871219a69365dbe86ffe0654f92dcb4aabd2", - "5f19a489a4b50db5c07b8f0b1d1347ffd1b89478fc24ee9f89a24a670a32de73", - "0eb57f081e27b6f619e4d0d7ad2a59c09d128f790a1ddd347c4544f30e04fd43", - "815c0ba40095d51a1f5d5f6de59b98b7e0ff6bf0894afdecfba6ea5347b2a048", - "3c70bc553d2c31973270e2b7a36faacfa354b189c7634ba0f0dbfbe4050e71d4", - "aab4a36c0678aa46369e515f9758c097d6efae69069c4843d85ff7db95e33fdd", - "877bf4c5df0ce4a6026b168148ee5c80d839633611260b7b05cc58593c99ef0c", - "2510b09f793de76d02576a201fd8d53b1265f95c58c226b4e096702047732eee", - "51c323688f73458c6efcac2b8413402a18d5eb40fd2b20f4fbe75e84c5db8569", - "77c341fd960221a947fd62474f136bdf83b489852d2bf2f5bd051300620d1c29", - "201ae2ba503f8a98c8b8db9b91122c69731b04785d8cf8899886c4877197e797", - "0aa3e82b29b7e5ef951b4937a0019ed5199f1d843273288b21934d602d231655", - "70d9d76f7e8e4bfd52fbce63c0785b9e1828b3fed6edb39f3711268d595d6923", - "cb6ba623010855b3eed24f1fa9d0c058a14da1bc2db3919e7ce5cf0b5e734a09", - "77d4f0edbab874914d0f68078bd3c3ca9b6ff9cd9ef411becfa712dd070ef7d2", - "4c198a70c29d175a3b4adcfd56c2c829a5dd6a14deba22624e253787e5126d4e", - "1356d72cf3fe97d46805e6cc004475473253fc1c2f97bf0feb7bb8d7edf04bc1", - "a0327114ee1e2ed22a483db30a0eada1d1f015dfcf70359f9546b5ba625b0499", - "e9151be903cf0ad413d63089ac432aefb129e6da42bc5baccfce960eb3dea9bb", - "9aea2c41bab91e2827afbc07c9e55699d0953831e0d732191bead7f8c1e15593", - "fb847e316a2775dbaa7be3cbfe262ac07be6114a0d671e57ab34426cc015996e", - "773568b1e029a519ab2c874110ef9f359305f7e292800e24eeb3055ce3c0405b", - "54d62a9d0b66c95541832bd1e4ea787860e885c0af445f69a6f8cdc5cab0cf76", - "52ca6176cd05043b170bf2ba84e85da0ecf44d1e2465e27a1e89d147d85e3af6", - "51e20761b5d6c698db3245c3ffaaf7f65b1ea9f60225255b2bf70640b3093794", - "bbdcecf5b3dc1e1ddf04220da632d0f368632863aa71ab0a509c1dfc0968e9ca", - "683a707004566580de7f8703b16c082f16f5b8caf8380678436c3ed6abf7c4d9", - "f96cb5c177bd8f0c60a910bcba56c45ff82e7e5bc8d49f177f381dbb7b39c427", - "69f8d1e5a43bdfdd9ab7ed6057ee917e4f2ea5d970a3ec86d41e99079031cc16", - "3f78173be50880b71d3b0473391e6a75e151031108023a23ee9255783e3aaa27", - "6eee22f2576eabf6274bd1f4a32795be48a0ccfe4cd121996ef67f94e6d17a5c", - "68c8efded9265f8bc2f8b51e160c56bf5af987d39083b5b8ea20d565fc3fc5c8", - "43b84fbd28e1e7763ec03b383a6d3434fb0c93e0f33aa7eded7b466c1b84a3a3", - "d23fea7367431cc9bbaf27bc6bdabce89e5ca866372aa7cce115db768155259b", - "06a9e26a956c6c7b2db82546062d70c4d6a8633a899c40125def92a988772ea9", - "482be65a542b6c852098b526da236983000ba9157a11add21294695af0c2e1c3", - "95ed485d57b3983950bceb6771ed602b9a75724b4a6cf4c8663c5cabb1c1da70", - "26e87fae28b84659fe04354535a13594a1b1d3b4b69669584f0aa4de35d14d92", - "508133b9c88128805b5d5cc33745e57f1eb2aaa695878b9bb58f68fd3ec31d22", - "ce7f1a81b53aa582e1729abe8ccf5cf9e7c7b201f85bb54f4c3f8bd76148ca97", - "002641d2c38389d48268c9de2ddfde50d7cfd6012df0890fad21b7e57a50839d", - "5f986dfc4172541e3c7545a56e5b5c16e079ddfa3a947ca9340aa751d62c64a9", - "5c4801aab545b04c5b70925a1d245c9c3bff3a20d83ce34fcf6e20a8c80a0b11", - "b761f9ed407e9aa1df628973c86a32e70fdc33a88bd4c88d07ec09b78bafc1b1", - "dd4154c09293062a15d2e336ed0e76fa6ce12556114de7266977a4747ca86880", - "717e45b449bdd662753b634ab3a527c4b5fc9ca88b8c177f1c3709c887cdae23", - "e1972bacaaa205da0d6d39fa99e52c7d69e656dc9343255e5e99461b474ef69d", - "2f03a5ee507df35bbd7b88f98d22f5cef2f42f298f1c2f57af5ba6418e3618e1", - "bd611d16802f3da4eb243c41dc84e548d8e1df2fd4a08ff82716ee2ab1781a6f", - "ba9c427c1d37fa3b3b60bc48d2f95a06b2e434620275b2e51021102a23b3f7dd", - "65202fe70f9418ebc9e731ed5c8c7b5e2ba577b63cc55c28ee6505db5657a384", - "002a7635cc41527e72341d61dfd29e2e12beb576ffe57007b9ac0123816c7a2d", - "9c3b41664909e47301386787e16fb425b81df5dbc88bf69b84a2e71218f26975", - "10de06a4060e2c0cb291c9df50ababf47698d94b0fc3dc5185da33172c636946", - "5230a3635ce2aaa7ad4916447e8c65c169c1e30ccdfcd699b69b79fee7285191", - "eb8360d157c35643fe686d7c6b89e8197c28a655365b6398994ebe27fa22203a", - "6e14a2e0fcf309a2464d9bb262e8e32c6b29f23d1773246e24cc734c238608ba", - "e45cc25768f62a0e4aaa8352158acc9fdca742ab8032a3f98f6de74e05669c93", - "c40fdf8c33100fe42783ea3e2684aa86cf8aea331cf94419c3188064c44a0e69", - "b0c5a12fb52e7612b26311554bf87c4dd2c537b9e2b9abaa65bc18dec8ba0e51", - "67331a26332465e643221922d8a5912c45f0731f5b928f02b725a431a6922755", - "17b378a1f8a0b82e0ef76cb89d24bab124a8a39349800492d2b6d938b3d03438", - "beba8406c5c5f28ff8ab79a0002d413fa9d162577ab0a77c207d4fe08a3174a0", - "6d15e09bf31a1ce4599fd7f3557ce678fc042556c8375967603b2ff470b5bd16", - "10f5f0a3c278f46d5827f5f115e1c337b757500a94f02f826c497b34d0ee21d2", - "bd971435c7de0eb915732aac9ce69db4fae9fb396300435549ce49bde0ff85db", - "dbdec4c1e1974844781ad50627c51e416aa962cec179c0c353c6db1c6df810ee", - "93d0e48f2fca4508a4c53fa1513e3588b8eacbc8573a31cc49cce983d35df435", - "4b176a97c77058d79837a021a38aeffbc7571bac1cd99936580ac20f4e4968e2", - "dbf13cbb4e24d9b358b81daac765438d1c1d37e6d7f800582b7e8d886a5f6724", - "2f0c203001f5c72d0bde5bf9389291711eb24171555bb5732710eb520e8dae77", - "c49d60c369b8452f86be140333f27889f074aad4ceff16b1b31c96d529a0bad3", - "9b1530d6da09b5ac8547b0e0f1ae5054d3b2b82aada1563021a7425297d0c889", - "1636f81198ee8164234afbb9837bf06fdc085154ef701f3ebbb94242ecff2139", - "fd704a2717474a567685d61cd55bd8469e17d23f4184f6ba031cf25ea8fe641c", - "e476f1dd3279d2364f220f231b34f266287a1f01ccf2844b5ddef5ee40e89164", - "e359362e730dc475c34eac2a91705eb1e06c2e2427175b63df50ca07777b2e7f", - "5907dc72476aa02d9bb1503d632e5af74c1f35e4e0491717a72488b5e0d3b70d", - "4b3cb6bff033732e0e6028f3875160708cf98ae04354406168ab5fec9e41aad0", - "59ab3635deae62708317e3942a585cdbe80344316ef90556526f617811bea450", - "ba4a5b2d0bb7449f99b2c8473e7f1f7e4d93d2bcfe0bad62efc6a7d8b9a574ea", - "07a5e217edeafe99b79b3d1b8f756a78ea2fcd660bc6e9ad2c52a8ea71992578", - "e0ed67ce984d40089e69a832e1044efb87bc1571a59e24863002f4ae03b8f03f", - "27afa382d307d846d9b60a06a97b6bb899480b0228e70cda199fa59b297aecf6", - "eea07baebc7a0b2fc85cf3a99e7621a4f62128fb41572f87be7ba85b177f0596", - "947e5e3e31488d0ab6794bb44995108139a09ff2b05d2bd0aedefa35a9c23ba7", - "5b20ca4f020e8b423892d89502123e5adde21e964f5b50708aa9c2c1fdcf0978", - "7a1bccdbea0d256a06d73111849dac93aa81a0eac94b69a1e8bed1fb624cce52", - "269c37d3f12948a708e2887e52d58d520aeb337d7efbe0719db48ef41ccc5e82", - "a1928d7c81f753a91a32c80a805ae30e8d076c30da7169a894cbf543903891ed", - "da6e2bc69084963c14051f70cf9e807eb8d39b45d62d26507b12d72296588362", - "111c4bd6fd87ee806cfcd45c4f6d54666b131af563933ea0352d79c096231a65", - "a8c3442acf52c0e78c69582871d93373fda80a6043ba386dfd9a4e93f43d92fb", - "c9a5181f189080e99ec81e8c24ad332eb8036fa867f4e13476c59a9b8f55f00e", - "b882d4a95574d5f9ff62627121b3675dc754a664dd103b06d94cc3100bfe1aa4", - "fa9a54a754c7abdb73999a0a4a5889d1a5def46462d2c156e34b834139f361fd", - "4d3f867fbdc5426c1c76e8862276e274aca9e4f1f9833e602e63aedb2865e2bd", - "67c15f6fe29e6d04780d9dcc880a7fd9fa691e1197612dcd1b89d9967eeb69d8", - "209bc504f7352ffdda86699140d54650268a5043a2bc8039bea2dfb195196b51", - "81f213565b86cb5a4ae8c39aeaa60b1391c6cf65f95f00840ee07a713b72fcef", - "e8e44e63c4b9ace52d57aefabef29533bf4e19f80fbb26f716e8d605b89582c5", - "8b155a84e29890c35ca4da7979b0c2844b43307518aaa5b6854ce0b912bbf501", - "f993c7e84a747d735efa12026bdb08d4870c5c2166ad48bb2c5ee2f4cf8f01e8", - "33728d78ec02a36b589d4454135f29cce9c24ea1c0835717166378a7b89dbda5", - "7666dda507e5f1516ed56757f4d30a398dc7732a053385b2154c653d7f97369e", - "daeeedec5891de553468e53f0290e939ef76b0bf8c551533170627ac9537e897", - "d046bf877a8be28c28eba17d5d942c57bd383df1ba02b37a6bcd5d6ff56bdb41", - "750ef672e810c280aa0f9ae8412fab1ba76e9870bd32390dea83990cdbe5251e", - "111ed27f4b26b3da9449ac48ef9c749b2860f26c44ff33abdd3c5d021f8377b1", - "aaeee91b83d05c2d3a61f37ece1f61cfeb8c3fd2695a26591bc4d534417ce12b", - "61a9d12fd16915cfaf53032201a122996deeee777c713fdaefc405f6cd9e819c", - "6d38d366c776d4faee7dc505556278c3d8d7f7892618818dab9178900b9c81e7", - "3efba1414bf9eb493d9ef89c1a1343da1e63e3508132e5c45c03d7a6b0b83976", - "d259480da2bb49af185cfbc4d05376affeec1361b52e0eeb5d32292d4dc2eb7a", - "45ac83650568f203b441f3c63d4270d5657a28d0b9c00794a8093f18c178c749", - "ad9940dd5e72364d1194ac4f7cf4fd0e483d988944fd7807bb2dabbecd0bc26f", - "7dcb3d13eb64a4143f12143e9b2442f25fa4bdcb06d58aac04aa2326d1eb6204", - "ed748ebe8fada73f19e931fc25398be93e58bb42ddf33d17a52eb2d693aab55e", - "1849d191326384a088c562b0e03752f0cef92341d36ee99645855fcb7cac470c", - "57f3a34fff870b720185717e33add1e25c16a79553c97c0d35692b8e00269679", - "451e93f492d9b470e0b5e8576fe7099368b80f530418fee32ea3919c74426811", - "7edaf74c260b57140ccbba5238ce8c6bd330317ef2d16087f17e92d77b803f21", - "c0c98b35d5542a076f3fc3db0508cdc7cfe49220ae6bb5669adfe8ef83d3abb4", - "7713c30f12ee7ab3cee78bfe2617444630319bbbaa073cc88738763dd8ab2258", - "59dabf37c7bbc4cf977b13f4ba8debcd59e60a01179f269c732e6e8e3123d811", - "54ce0d6f7d1de6b208c71f9bd5b1a2be9f14126e5ce0e8e36cba792d2d40f9dd", - "f3c8953a0ea534e7994d1a4c99d981b9289b92cf6d8527cad9afaf4da61ae866", - "eb0c0c95b0daf4d27372c7c325a1b6a79019d4d2de9f249ebabcb1922f692688", - "9a5179a57523c06d7c963dd7d2d433f10fd68e694ca8515fcc4a15964f221d41", - "da306518e3d3f0e076bc0a9f47f525175e74c6b8b9de0ad05bf0e745241ea2a2", - "babd83c20b6d2f484d7ac24c65e7290ff25deb4bf2dbe028d4a70edc5606852d", - "657a0e514a1e4e30d19472d978bfaa74cd3a38ed266c52501729806bf30e3885", - "6f3f4221fbf6f3258a9370c375a8c2aaeac88c394999f29894c651723882a3d4", - "b07eb82305af1ca3bebcf5d8777fdfff1747160598959e98b05c31fe627c400b", - "7226ed8737be0e11716e3ab79a1e7da811c54dde24fc54634feb1071c7a680ff", - "cfbb2c3f479efc0433346d55f9d3c8b64d3dbc642528f2e9831d5b1499843ed8", - "75a96775deae4c7647abbbfbd2f0286c8facd89e3d7ddb788cc52681c763ca01", - "c05ca40de74c94a780251936ab1ab4751ea8ae11248ecd046bb67be708ce461d", - "7a326373c4a2b4be0c35d3b31d98fb6b8fb5bfaee9a5a0fc6efbb07f3123bad7", - "0a53e4201282e4cac8cf4379d010c4850dea0e80f013774c27b462e9961197bb", - "8518a67611a4c18f91e82c531d7e27d38104c462038a83a8961bf1b7832fa90a", - "2ed197bc6ec0c8d78882e27b643aab911f6d5155aa2c27a7b092e460520ad02b", - "8d507f0a08f05af628f527a8ac8e363adc2d7495585c7e18e4745b48fe2b00c9", - "e030109b9c82e3b2d8cf1690bac7cb15e68cd7d153e27335b10a90a032f9bf07", - "34c87a65ca0b3426912af4dadd4e6a61d6568a85be2a328482699d849f1e6ff9", - "96b6bd203d656bd4b7b25f2676269fdc0c6bf4f4a4556443bc63c24acf4f3608", - "05868b3f027d62bcf7802edaf186d8166cea3fa00d9eea8bc68c34627684851a", - "cc2d3944dac1de9c40d69ca552949ad4fb4622ba3109e3ddbe9415b5dcecb4bb", - "73a9e51d9fb2d436a453b9e6a86d8f6479c273cfcb534e042476fbf9274cf375", - "fedb7d82fd74dfb18e0deccd753e26a5fbeb63ed66a7eaf05a028ccb531389ab", - "c7c08fed128323afadee94e8fa54f9003e7ff5bade3eebb3b76f3a9bc169fc88", - "160cd418b0feaedb50405f7b577103d3089e55700c42be5b454e5014cfcd7f1c", - "f9e50aab90e082c75871209eacb29ba5c2a7a4755fdfa6f614a55e28edadb4e3", - "d8bded8b2fcd2201c3b791c79fae7ea8ff18bda4f8b2061d390e2d76ccdc063d", - "2d897a3a77067c5eef9a2d0fbca009566ae9b75e1970c92f6ed9576c347f6ab0", - "62301be2b647f63ab4cb9227e33723db62d420aa2a36f63fec33ef797ce0c8ff", - "e9574bf7968177bbd394201aa4ec886b1275b075f616a7fe60bf4258e36d5ada", - "f65ad1db1ef03d7f288482137d84454173ca888fd152667448cafe1604b87a23", - "f1d98d04fb05aa98c223ac3b77186eb9bd4c42ff5d3342b49e0257f1913476c0", - "565fad0951ccb1385a92c4a942e67bb11c832ffb046b891ca5fed1043a72a8fd", - "1e19efa146c6a337bc5e94f0e49eac0ba1245e6a58b02533ff05158f7c1bc3d9", - "3a068efc739b7ad10b69e64c8dc82fe6620ac07f3d1d60443184b7632d41f764", - "8d10f8d2f5a031499119a734e08ec6b3460922325b1fd3dd3f43030c19c5e67d", - "6aa45ae660e354270d0e177551c44ad196f6fa7529af50cb39f95429446db95e", - "c9c7f230077a212f1a92166023c1dc3055527313bfe2309d6a4cfe18fa8c2751", - "4bc1b1f59c0381b7d19e38c18b9973e5f88ab5c94169b7cca064715423fbd0f2", - "4fde5ceb3a6788b5d495f830008282365eb0f64db25aa621cf07c02091b2797c", - "c91d880c20fb5b6ffe0f4f28d68aa4b86c2436be645ec15bc20b53d47dc89c59", - "d976f75f1b1dce27c18605fbb0aaa72dac750565f7a7cf6733141fc0e115a5d3", - "55008c3d6066eb67b3300e91581222634bb7151668dd631e22d31652772e91bb", - "ed88193bb98c872bbd0187914e0bfb29c3aa6577f7894816756ad8d2f4138e8a", - "28b17835763b3af6ddf49f7d6bdb1dcbaa2f967938df4ed8aab51793a8ef53b3", - "83702391ba08a06d56d0cb2d4509d01a6c497d3a6cf9db6e4ee27a788b08b385", - "2224cba4cee58cf9b04a74da642e7ef3425c9a25ccb3adc085d6dc9abe231ed7", - "eee2007a3f073182ae62a3dd87bb27c20d596a98c2c37e2f85ec3f370d673602", - "1b93b8ec84e7342e27cea1e1c6a390ab1531d74999b32ef5aa5e261b402427c8", - "00915788e90558657c3d288016a96fc2e93c921ef6d84df514ebd54287bb4125", - "549499ae488968fe78fd596b7134552567a0a25acba8e263b50826022b285985", - "8c180c1443a521cd1ab83d22e07b54f3d621e9d5060e2b4abfb7b12e55db93e5", - "9455776adfde9e0dc60f399766335f2d71fe06b2d2f6a96192368f555ea5dee0", - "cbe4c921d2d2be9f26bb6398c3eab4e58ee77f87a5e4f8706428ea063c8093f4", - "af27d82f525f274d861be78c4d9de9a5f647ef90524bcf361056b7a62e1d3e0d", - "565ce02c42ed3c41647021be28a82405523da52632e3584a4768727e0a9b1ee3", - "fb8d0e47fdfc08a262d60846ca5f692617f22a228f1cccb4a9035ae84b60c40c", - "608311d84883f64f45ec8e6cea5057f714a6faea392dbc33c9484c4830ae51cc", - "30ce0d98da41b44bd56a938f2d973d79ac8081bcb1aa1fb51a7288dbc27faba7", - "c31a48636da345f22543c7f5882057a0ed90969d94cca2e63dd78efb945ba1c7", - "b35740832d2317a1009b44781c1ec54bc24d0ad3c288100a700111b552c941c3", - "adcc74003d799ed004ef6fd5ba18defcaf24bd6685f24503c8934ca3e5edefcb", - "f66179c80546c629b7cc88709a91439a0a2a9a344e6354b3c1d07a07967d50e3", - "c446031962726196a87244760f03a446c5e9f47cd6b46be6981ee7f9a0137761", - "1ba36c393c8ecbec20ab295a0ac4786ed0623c0c6d66b5585946d790ae86dc1b", - "205943120fe4be5bc0b05e7ebff88e5e4f826f0fd16e1eafde7dae8060ce84ba", - "319c79c6cbfe42abe010a91b6aa01424f41ebd6ef50be88491f4bb2a79e75a3e", - "dd90f2d83f440f7e2828b37d4d0adefc83e8e3b9aafd83e55966fcf712d674cc", - "631e2c72087f515f2debaf1a87d6d87613d20cef90027198af41a6133d7e1822", - "2b30c637a8eeb8503e6e722b18f67579a387e56ed44745690d84e52af2e1c3e6", - "8d1df619edb643afa64d41ed7b50208dd2a2cdb2bdcdc83eb6513b0fa89a267f", - "4a9a6242fafb9093c59736fa301722ec7a82a73d9d88785dade0232677cab2ee", - "eaf68433697020b410a0b42fc0adbebafe25da288c9fb329931881acdd394141", - "a7a69147eac04ab702b674724f804c8930e45c6607881277166f31535a74ad50", - "2764b3243a511bf85155e63e7902a400a5aa7af09cf0fc5af431c50dbe9e3d75", - "030c77649c9696e2f5ba87c85b25bbb5a98f0e59ac0407d17e8119287b33baaa", - "1995edc46960155d39997a956c396c6a812feee5f63fba881e657b03ee1776b7", - "0127acadf023cf334c3237f1b44663872470dcfa4707aba98e3872ef29f62fb0", - "3cee02bf7f01fc510393038f8da5d38f2fe1c22eda9b55acdf60329f24e20be2", - "bd83bf6110bedf901c6e24f9e475b7245df81adb13ebafa9ad898e308e38cb52", - "b2ce89f8a166444b465a342d64ddc5f62f022761ee3d81daef34a94fd72d77f4", - "83a73d6369849c8d020646c90c402839e4e393d1237655680da6e7e16e5a8474", - "5f5707f4885341e953cfa4b45a6fb1c9a9b2bd33158bbbda2051e8dfeeb7d4f7", - "38eac3d57e2cc1f62433c909652db177c3a262f8a568c7514916aa7dcc33a200", - "a9e498a21762dfba2180ed64e6fda50f60e6dccd79eda02b53ea20a58ba6f341", - "af78f19e17792c0e5d31efb83cadc198b7a7c782d010f852048300a76e7db3c8", - "8a050c8bb4afbe1c4ec128bd2b4f73a39109a27a9d3ba940678550a6f705578c", - "ef5748295ddc7d57b60d2d5e70e81f4507d21b63be2c1713afe5ae44c3791fbc", - "098c34ea74da6e0fd54220f5b01d0e074934b14806bd465d2b5427465cf71841", - "c903303e548e9028ce4decdd86b570499066d86c94dd551a33bae3cfc7c40c3a", - "18b2c340875ea18d994d1478bbfbb0411e24b93a6f16d1be1af4a44c360e15dc", - "fb03c664789f9bfc1ca28ce99fb178e1291e26e5a4ca07fbe271668038e08b78", - "83e1993e66525db3f861c815bac1b98d67a525a1d8f1361ce4abbbe6eef88a96", - "999593a8e9b1cc37f1358baffa678f5cfcb03de4ed1c3e12ca85c916a34bbef8", - "87f767d9168207543d611aded95b36b97b13e667836a25a2c07f86872dca27f6", - "6c9b42333f2c3b22b299b5ebeb17a01a88620292f23157c5f3051442c6861404", - "69db9921bebe596baf09b3338b5223f5be05972468819d6ab608a69178ff2af0", - "6a220914ba38c658cd20c363c09abcd2784b0e7e98d4e2a8d295d3ea10eeb775", - "e0717197df92fb7eebcd2fee8ae7aa45930579f1753b191b3eb7585932070a9b", - "4d65db9bf1d7c936cf0107c76301d06c59e123c779edf3d13ae7ad73a7a4fca3", - "9896e7154acec062d207d23cf3c9281ed9eadbe618c2c090f161033e376f7c70", - "a68bdb2354111a11b685d6b42b5337b716dd3eb7405099c8fdf64506314aa530", - "f615c8be47948f2c9b9259258548b21026eab4e50ebbbb09c66755d903ddd38c", - "be70a0675ef918f8fbf72b4c2a6217c0e8a1b29cec96f38a380cb8c61b31b79f", - "6f73ccd9126064282befc8b922c0e959102c4489b4f8990567d2ec3a6051c6e2", - "25d51e79260dbccb27cb452cf80523025b52419a2df2157cd17509227ad4a671", - "f27124882de9130349389eae85076b59eb9b0b4b3c04b943c80bded8a43aca37", - "aefbc188a9d8dbefc8c06ebe795e7098bc8548b7800cc21890d6f3652a64f8ab", - "0562d728ed420f140ebbe7813cdd8d99c975ed3f1169b890cd76c2161e3ece01", - "e983426fe4732725314e5c4cf86ffb4cde6116e3694bd20d0cd8486c414b6e6c", - "bc67bf9b1eb5629c46fc849858757ef7a6cb67798619aec00bb373f550a49401", - "64964a5c78ce8aa2b68b1bbe636d5fa47b3fb8a9612fba9fecc05e8740a00dd0", - "6aad0cae02bbb49db330b610ff85706694a075f24a37a04a0b30dea6ecc57be8", - "885914a911a99276a93d8e54714ed77bd902393555348ae59364a25951c45097", - "a4d7ca9925a707133e902176bc2ad8e6f2a638c9289a370ae20857b2f9bfce5b", - "3439f57d464c6ac00aae74387cdb550e437cb5c7a8842244276b0be6b0421306", - "5606042930605947a6a9b16106e68e0e4d7adb9a95db9c1cb55b19067e4bfe43", - "0105a9c7fc9d00b97de14bafcb1c245bc072a8632daea49d1fc0c13a5a1e30fd", - "750e57b7f4d24c68f7980e4cd39a4bdaee0f2604cec1048f05bcdc598586e32a", - "25674f021a5a4a893c4cc3a70f88bb951f5cc6a778d247fd48ca9c1c3cdbef09", - "0a2a9684a04ed808ee703d167f2f4903035417c3837189b5aaba389be767e809", - "96e5fb2dac3e6910d885b67a60db446064cf7e7f3e0d6f2880ab8e4e9e8fc27a", - "bc57a1a37a0c428dbb6443844e668f4fc654d952425c6fa9618eab3b2ced3635", - "15e0b077005aba39825030d142849098833027f575cc2b144212ac120211cc0c", - "9a4580bf7e3ac5dd01ff74e11423d68cef64c9c7ee46ce4369f368a60d64ef80", - "fe2e48af158ea74f8c46b6bd4f245de6197436b4d0977a48cdbcc51ff60949d9", - "1e73ecfec4ac994556f6cfd906f5a3e2252824a3190f0a46b567956ed865918a", - "48bb46a5f08b35de42f40d019b486255ae2178989461368c9517d67c0f1aa530", - "ca7d625d0ba8fc48bc072244ff0e0c78f9c87de5a0a95f9129be3c632104f59d", - "a45aaa89408bd1577329efebc9258d180805bdf954dbf8311af4c5ccd67d1837", - "740953a0572bcd42e52096bd3e23367fa19ad919e0a2499055c48451ed347617", - "d36107233423250e95c5a1cc97147e8c9bed2dd0e8c112a10a8116d4179141e7", - "64966538261ce084cf9563b28ed8f5d16ebb0ece8259aa61f9541eb160c5c66d", - "ec7d7f38dfee19fd20af77852f55db90925fbba995dfad16b01a62d682518108", - "fcfda11ccac9dea010e14b542b5a0edf4a25ad515f97495a8f286bdf38c542e1", - "1403212f951016fdd00f673a8e32badc97b6c54f965ed20802736e16d4087869", - "a40c968e1e40af78d76a9842db3ebc7ea1135d09935c912857f28b09ab528f17", - "dbfd95abf20e264fb8347f789fe4facb700604f7e68cf35408586ce4fe0cac71", - "596a5d7d4b95ecf6f69fd65f8a21f1a3996483b210e68f6e43d2e3abee860e38", - "839f36f230490c5a4317c487c896154c15cc3964036bceb3e3b7e90aa3ee161f", - "6e52f561d9caf3de9a317f07c266cc6fca0959be17b13b145d65dc24ee18eb0c", - "b1c62acfccaa818c3d5c476869703fea050f855cf7c1d09f417008d691e0d59f", - "8614ebc5edd7b406a6f494b694c709bac3665e96909ec8c26249aad938c93a0c", - "48768e71cd69fe3e2e27b8d9a05873302be3e9fc8741cb747a1f4bf35262cfe2", - "4506a925908adb6de130be44c54c3ad27ecfa27fce39a8c54f1f63696a00cdca", - "d9205a49bbb4edde240bef351c28958d35d98f7eb37c7401192d1f4b52903ead", - "f894b8d1b3e2f8eccb40f7504577d1ad40d0be0c039b29ff20e7037e9bfce3fd", - "03bc8920163e808881413335881181be4b8a64ed3d9f0f1bf93f59e92a7ba0cd", - "969be54df64212729fb12c1963c359f836326657b47f503989ac2d554361b393", - "0a1ce6420737ce5169f435a9d9cf5d34046e86e91944acf993ccf22f36aefff7", - "8b6ab7f4576f7f6da8997c7bc03e2e845fc18efc3d569691bf2a7674ed376a8c", - "c09dce2c55f7a7b6fe453fe72d20e007bbccaaca6010fa2adf79ed1206d08818", - "09524f3878ba6113700206012f6a660eb349a5e9ddfc110da10522330c49f8ca", - "df939005dd88cdabb7a79ae822bb643d33b5397c2eeb06e45fc1bde0b964b780", - "bc304fc61aaed2d695d4ea67ee3691e843b6d8cde76db5e3fc021f46a1ad4fcb", - "d7f1779b73bb943a3693f5cdcd8115b9ec1710b7674b98c4a3bb5604de5fabaf", - "217276473ff67670f0de76ac4672a43821c52a26a646870fa2fde89be279e23c", - "6e76e272876d7fe990e5d2afb04cc94ce8fc57c0f62806e14e7d51bb13c70601", - "9eaea4fd5e139a8f9e9598d6a0e5e0ceb47084cc7a6de4af7bff1fe64a9a5796", - "26cfe64af4198d60e64f9243edc42b2e40ebcdd575aa38accaed856e7ec7727f", - "c48b241404b87c38c5a6fd91a1751659aec871e8aa1134a22b7f3c74a3ff7465", - "c1c83b9d1693cf246e68c6bec149621f48d117dfb52b827007606009b863e56c", - "3c4a05627cb4960982f9da0e45541b6ec1b6f84fb5b9887a99189cdd1bdebea7", - "b0bd785e8819aa04667e893454417b7fda5b997cf043fe24bf86fbec05c85570", - "459c5a34e6ca24e3dc5ab922f2b9677540f3398371933889cd7927c626eaaddb", - "08b266a50d0588ea254e418e8b37b3e24cbeb17bafeaf6568d0665eb167dc343", - "1973becb33833397fd769ec37cb672d5ccd59ad7bf3f342ec360d0506fd3330b", - "f7db9706856d1be3ab5ce6e7de775c1e4b5cb18e2b55420ffe5d8c5378830bda", - "301d825cc77bee3046f7a49a05a0632730d29bdae696cf17028141555f766a26", - "1dfcadc0444f4b28f7d4eeb704a0e92a04ced5d2a4cd10a7653916e9d96c3d62", - "1e9fcd9e415a10cc13117b425a9db6e06252d63640ebd2772ce3407072ee958f", - "1fd12352354222fcc13ab9b0e9530f63da2b47e470f0b08c653f6eb4e586cdd8", - "01155d66e3cf6cdca000ea7cc580736f47ed93aa6ccae5626b233a9c53178247", - "0d5e0738af6d5f39e6469b54fa74e278b238d6b52ed53c7b5aadb2b9e1d6d47a", - "dd01fe524147b17f4d520560ed95001cd649c28146f461a134e515e9de1dbb09", - "8421a5b75469f2645cb3ccee2f434b9261c84274ff050c37853270cdfc6ff14b", - "95e5bfd5fd02654bd7f9404d2daa98d95ef52548ef368b2d584ac0df68a4eca9", - "5d12ddc833cb4965ebcbb0624319ab2fe903c580e5096b168fc6e128e579a435", - "c89484471c47788850b10b7a8d86d52616fe15f7c6552f3d1b73907ebb68212b", - "fc9e01d542332e318412c0bf6a5b134920f0ee95da76842615252afce365321c", - "7e36c06ba4708806d37d5a787e75aa2853a7e77eb000a14fd3b0f4b3a5dbc6b1", - "2bbb8b4c8ec47c1d125d02f843e287bac95365c96c1ae63a3fe231122cfe778a", - "89879eeebbd8e39c3f2c796c6ec8b854eceab4f42b6b839ee962daa7cabc9d38", - "1b16da827db7ba00487a423c7059833ddf0a6e5db7df5d3f1f0eeb6f6f72de0e", - "f207d419876220e9bab68f92373040ef1ec8096374b4d1e287d46dcd0470efbd", - "3d73d5c50bd58b61038956500381d347008fb25ce13df3cdbdf6358c79e87ad4", - "fddc1a900c9128a8aa282c0b00fdf0d591bfc16c620176652763904d537c97b6", - "c9dbe8a06e58e89c315b2677ae5c6491b6a47e0e76c3e714ecb2b1b576a6d694", - "df1120c248778b407a457ba9f4bba150a601f1d5571a5cb46f166de95fb1f860", - "dbb5e0d7bfbfc9d437d3d95888608b7a294782799e45afddcd61d6283ca50f4b", - "48305a3728956cd2eb4664bad14691a66539e5f4610aa3fbdab8f3c10124c310", - "97725e0eb36e5fa755f778728b99d99d34dbe127d9d99b8be3179bd8f2245fd6", - "8ef6f504c1203888fa4f4c6a08f226c45d500b8d03d6ff381b57fb0e3e4f633b", - "15de64c9efa2642abdf113f61c5c2229456e25c4c7836bc5901edf55e4d43d91", - "d4b82a15fc97aa6193260ce3f153282b6e04d6d1d5efba950af7b0e1bf24da71", - "c83c1f0606d69f5fd6938a8a84477286d460b1e0ce07cc6106105b181f3b360d", - "24f644c19ca8bc4ef5ba46ad46fa35e79e74b2c4a3b0d3feddd4e95f90cf5f91", - "320dae24aec56aa5255dc041bdaa761173b3155cbffa126799bddd3f19b2663d", - "f065dce818e35ce631a87842c831eb3fc1a3966b5b063d5c3d6fd13e016c79e3", - "1c96ed40dffb2c8297db93fa8eaec23337d81cdad645483d9bd56392d6c75acd", - "d2f24d2b640f000aceaf3287a7f50a20af50111fc7d7f1fbd4c84b06900fc949", - "911a1a321c0a3ef78562418fd49b964e277bda6d0ba9659ddaf6ca00986d7766", - "1fc3e920d752425396478f40756b55e426669c239f3c203fbc868bfc9d6a4020", - "f6f451d2d5256ae04c3dab8cdab27cbf2dbc5c46b4ea52dc72721e8fc9752a6d", - "6a3ca02409b6aed2287d6535004a71b5dd99ef4d21b4df1b1e3df78879331f45", - "796e2246e69adb094b2c767e156ebdd12736084f095889c998a4bb99cb8578f1", - "26c78aeb26f103aa153318ef04b38159b6404ee886f715f45bca857d5c274fdb", - "f2934aedf599b6b0be0c1e27eee0571d4b3d047f08266b6df7b65ccd79358ba3", - "48b3a4059445de62909df1a3641815f36510beda54aad02b54c0407ea568963a", - "ce2b9d52522d40769a8d1ee3f70a925055e90ba4732742e36825d9973f98750b", - "5163311f2fc7f86b8b4eda6384771085d04f0ff6a9a0122e59599410b67a0f20", - "13af520fe1a460a2d4eda7c547747d3da94b54c8c3b40520aa3f6a3930b912ea", - "cf81b232acd43721a9c0c1af202bc1f058bc4a8f7dafec9046b1cb866b941410", - "00aed280afc4c03997705e235b41005f2c6a4e58b50f01f62a156b9a1493ff79", - "e1a05936d5f4249b840c6a1e9f0fc85b6e6f2789e6dc8dee764e78ba10a81101", - "42cb843b4000bc80c2dd40481aa8fd02f7d32da61f1c83fe9a806c56159ffde0", - "bb2f3151a5d6a7964e112d843db5d7fafa98a040b90f53523333f6de82a700ee", - "b14c1b8b82fd55d07fa0ff644f630a01adb074fadbe89185f42c89390d02c20d", - "88dee4f14585b5dcee0c561204428995c7204b61136f7d09da58066851ee6ca0", - "10a2188db9e5335d896754e7c3322e93ccf47b9d309f54c59ecb0f8d244d3a71", - "df76b51a130a97567517b105efd001d1e6ff0b8b5280b438f4c7a1ec5a5f927a", - "ce1a7977e067d78f4398bade4016172a17eb4f1fe13d8c797fbd7251397ffdc7", - "0f120015d2006fb1c48d75bb5b3c62d75e99c17ac222f8371fab41af73cfd474", - "7c688d5d08efe478fd47beea399a717b6fdc3605e7ed7fafdb4c5da6dc1fefbc", - "0f315c9774a3b677b907ee070bfb00fb6f0dea4bc1e722b7efbba18c213add6a", - "5bc855c1af556b92a177724c561c5e9c29ebb13260087efe3356582e5817be54", - "74f1f4b538957f9767c92ca8a753c2fb072edc2d07dd489e9e666a79a077018a", - "f8808891d9160b2d8ff09983f1e0f5c63dd4aea2a4a611482b190081db1562c2", - "69c635d05991c52dc3143560d9681f5281b40af2846be0e76cf6af8bfc86f051", - "f0c5d7adcfb61c110f5ee3c2b678d0d2336a48c14f342741dc98615462e811c3", - "4b4b2abe6e9ff8582d235e5518afb17c4352a316d2625786c864d94ffd04daa5", - "ade3dfbfcf8787758f602b345f95ad0790a084edd105b559fef1068066292eb1", - "59659b9c28b7f6dd370f7fb97739b5616c325b634c96038df438071709beb1c0", - "fe1b7766b72a12ded8efe17c1fbd4cb7f4068994f6e2696223c3810a70f1c535", - "8a20c31a14860d3b113b3a3bd18f6edbfb4922944f9d1e078d859d02646d0ac5", - "bd98167d9430c08e0104941f6db2556a8e341663bbaecb664475e44e86a4c3cf", - "45a66d220281c491893682142a9436b64b88c7653875bf9a96f89de72cf3eb59", - "1e4d07c7476078a07feab95c2186bcf39a1acb1234d19112f4d4a05c455cdef6", - "42345efdb9e8e594b444e6a064e73b8f1a0e62316c2a91c4add5f5952dd0ecc7", - "e54e2184a318022d3cbaeb75b5651f903313de4cef9b6034f97c0ec380d6991f", - "08de62956ad1cef91d0c96e597a717371b4c2e80ec7587ac0e2b90912c0d211b", - "91f1d2b3730b6af0bab9827f16e571f7160174ef79ece243cd213181bfecb18b", - "0810c404bb1a9880316c4e3df99168e290676170cab427cc55b89b5dc55530fd", - "b88314961f2256fecf99c1540fb51572665ab469cfcd7c76dea70fabbed460a4", - "1eb88521c71a1363e866a3783a6119c4019b206fcdfec85a394ddd9b21494495", - "2ed41cd54fa28d0b9bd2d6cfef54911b558139a12294138cba11767692cffd7b", - "d66f3b3a5d172d9f64d8f79f07b01d12bfbdef1f3ac9980bd7a2643c48b4fdf8", - "5c40dde377ad3aa43be346284f2ccd268cb8e83fca07aed279da8e4bd881a202", - "09bec65b20f62cb97877ee771a69215946eda8106ddc0aee956e25eba6577370", - "c6c46badfc140fba2507f7a2d543d5fd5909a86640688f1fb56d21a17aeb04a9", - "c5d86fc562f9c705cbd33ec4fbd79e13c312905d93132e21738123fb9e52e8ae", - "d975977d8c3cbddac106e075c29f55cda83dd56e5bb46907194ff5f5e8f20fff", - "1aab347421145679f5e9788c641b00f0002e9032e9019a002441bd8d9107efe2", - "c5a32cbdf7a3dc680ff246d4318bce7047f8d5ce7edddd04a471c5083cee7cec", - "1ce182362cdaf33597b98bdb65cb896b759da51ef21ce88e3cd107ea04ea948e", - "1da0c439bd77167fd603d6a5f893faa4e9d2ad38487f30cd35a88ce0271f69b1", - "d5430def02e87e5e857714106d48e6fa9a56a4f7e578e2871a710acc4d4a93e1", - "9ff5bc2e0c6de56f257433376184cc3b06890c8832f6cf519295fbbba8d1be5b", - "ae2ed76089bd546990e3242efa3aad1da610f966011e3dc02ac54621f1ed9f5a", - "c743ac97834c56f5f0a9968b7ee16cef8b816289d69766cd76a38d851daa2416", - "af7f5e54a5158586c585dca38042382d2cea37a49dd9e939132721c6639aed01", - "c5423c2276150852635083a33d1d70acfd2b23a016a8c35ec1c9d16c75202a7d", - "3767b73782747d92a2ab3adb2c277d03e3c0284da86e054b6f7aa3244b32c20e", - "f20e3f4649a857554a5b0393d12fd159a22855dddbc4962a4a127647dd173603", - "2f39a554678116542fc588c4067728484d4ef0df8da3d2697473c616cf5038c1", - "1cbd3cce3fa8631af7c14b8e529793c52208e7a596bd703d0bd9d58e4f4a9537", - "2753794b6a259252040892f51ff56d839b5d09dc963c68725492d62e5dfb7556", - "1ae2f5a4d72c8a3ceedef03767c2fc7af1c097b3b73f1fb241f9d6ed50948f5e", - "3006554ffd265315655116445933808fe580ee681bdc7b0d8989a2aa14d18872", - "51c635df967560a49b0a5867844cd216e77c87d15630554d4df73648a226884f", - "10f58c432d7248c1b7f1d5ba7d86f443bd7a49787408760cc2063c4ddb5dbe94", - "e10479bdfc6b62ea9f1650da6bbe6ee8d9a654cbc4b273cae607c539269a34b8", - "853d04ecf1af77ffcd6de5894584aa33d33f9157e0c026c0a81ec775f34b5acb", - "0e806937f7b6f18114bb08b4f7a4306e2a0a5f7d1c26a85ea03b29daff1fedd9", - "b5f0633c36e467252a2a2a080283d19b0af01adedb76c527fecddd835d6f431b", - "3f558c49486da14dbcfca7fb60bd7b11add5390dba7b8bcbd6f0d8d5fb78b792", - "6a0fd06027b825d278cbb22c2216ec88a885063bde5813517ab2eea94139566e", - "b5de4ea38cbbfe462f93eddc29e6cdb7c936241a0c040788e21488d4903b6960", - "42a8cae8f2384fe6e1e1d76cccc7f139cb07cc5a2c695590a9fea19ba40526a1", - "cbefd9971bdc746fb3cabdf24de1c4763b6818c5e152b62b0578d228bb59ed7e", - "c6c5b4b2a6565671bb3d2f56363cba84c7200ea4bb486781dd9c3153525cdd47", - "0c34e872c0852e791851d7e35462363e1be551099508e502cc7b6fa2ac6fd8a2", - "c26f46527a11f73e685131cdc1b15d73afd8bb02c634e47f61b48647b58ad354", - "d0b9ed3149b8b6ccb81543e656bf5885e95b2be55ff0778f4bb46650fd5f9995", - "2d8ba3d6aef946fe14b1ef084d0d8ce700f766c4da428ab947b81ed6b5b922d0", - "bd416a2ef56dadf61c14930d16ff488c2b8d33416932f2fd347035159e4b2590", - "5f572456a266226a55e02bdbf09912a284c5338e549bc7589586924982b90996", - "c330b8084374f3c68ae0ae62c5bd42f89fb8372c6da7785495971c182f1d59ac", - "a04ad5f327dd12e4cbf600e1b849da4f0b9a2ce727d71c4b1ca5af0b0fd95390", - "55b98c1d5f30a4731e41904cf6e9cdd5f0c0cada2d39a16361d0ae69ae593412", - "0e7d0266bfa30168d078757e5cd5695925f10a3af8afa3f3d6eef07fa59f36ab", - "a1c2826bd65ba31ce10f15f0380e8e13bc66fc4b1da8f4cf089fec169fe5c257", - "6f392faff860ee7b447e809b08259c3930fb4137da04f74c699f51b07cc4126b", - "5417c55d5f8a7190911f3988576a4b0e18101b8b587903beba35c75c2df6a84d", - "575169fdeeec8bd4f58385bb419aed9ea46961163729d37f8885c64f00a5f698", - "5c0a6e8cd261abafae36a86fb69856ed9f4f2d79c73c1bc58f00bc8d725a9c62", - "fac418409b082ef70f7f64cb27ae42ceccb64c231c0d18fccae846022c912937", - "0cafec3f392b49ed269085306a452909eba50875738e028af5195b3cc097cd13", - "fc8d4c9003166614fb2ae867345319416d6b570abc96614edaf3f1026c1248f3", - "c04ef67e3b74bc912e8f2e26d27afe3d4fd33d12afcec1309562f11da8edde1c", - "79461696d2e33385222e1b8d3bab0a5e402e4b29628bbc8a1c7035a33556e296", - "f236f723f31086f60475d1219e88012d283d15da0dc5507beb341f6d8e10415f", - "5cc206dad9d140f3ccdee595e20987a2e087eb6614d24ee714d74719a8cfce16", - "692bfae3698bde39d3fb6884c22907093d0dc702ac33579ea7be3bfe6e6570b8", - "cac9bb52c1bc0c436badc76278eed82621d11dd8ecbebf260b7d6c78b26a2ff6", - "e5cf596f23f620885cb60376f43a9914b6b46d36e4ef1478302e3fc66a6ab5f7", - "9bb186eeeff59b5b8c16ac6f5f51dd484aba838c1e4757f14b6f7de79baadb3d", - "5d5fffd2e62acd860a027db341e7904bc65fc7546c1a0427b9237d6690f6409a", - "abfd03bc9a6ddf02fe9e794ea3fffa40159bc07eaac8cadca81f61cdb35e6b4e", - "10a697ea929417c43813be35396f976b67fcce454bd8bbb5b1adee60e35160e6", - "995deb161c4dd33bbb58d521f997d456d9c1c2f7faaa54615e2168a05c593734", - "02f4be8a7f2dfe14d346c914555a3061164ec03ad1031bf65464d170ba8bbf96", - "63b134fdb14661906cafacbe0448a1bcee26e5f0dad4d4644a45f3aee70923b2", - "2961abb7332cb5c9a9b7c6792131288fd1ab70e53831c05e3cc92cdcf56da222", - "7d22e17e3bd406963bd15a97fbb132bded55fb5e9ff067015d0aae1549f81f90", - "4f71dce27d1721b88cb3cbde41be45158d8ad195d6a84c9b93a519f3e4ca9d46", - "0b2f46637b8c8a318b22774007a8b47a6ac9d48437c61c617966a1f9e43ec1e5", - "f7d905b1a9532ddcf91d49d5a7ea7c1f382268dfbf205a43c1bb85f5b9be3974", - "223a5f2173756fbf5c657ae0025bfc1d87b385be7a97e439d2e94d3fd1913ecb", - "dea6ac59fff5e7c40b25a12e7bf2430e8a63e522909194fdc3e8d5e8b442909a", - "b48645435d33cace1d589314883e81a91b6d5ed386017d2f3680cf97c0100d20", - "fe96b9923c7e37c318ea361c550a8080341433e7422be2b762b95fc1f2cdb184", - "3b1a01a1d9d932663761315e67646719e0e23e51c19acf3b9dde44d025d5e413", - "1c1be365ecf1a8f45298d55e96c6f058221c99ea4fe838ae16854812abb4536c", - "6eef0f0253ff97650e2e87677d65a1e41b02fd9330009762efbc7333178d2133", - "c08a28bf9696888eade20b7514fcfcb8e457bc224f51410e9e012d7cdfb701ab", - "1632e931706ede8ccb19d0aa258223dc68236072be5ff18965ee2a543930de00", - "0d6ca3073a121fd4509888a94213c2da083972caa1fd17d1d9952fb14296a589", - "83a980428ec9e9b8adee2973b6c93b20e64482c911b718071c72b0bfcaedb224", - "1312535e74899eb3d022cdd5da6eeb4cc7462f374f6faf434805c3ec0fb84f22", - "53238fdd09ca194ed47ae33aa646c48047941da5d8f02fddbfc13340eda6bbc6", - "e7e49a2cb1efdaa593f37957cb5e44a345025b92a14e01f1d3210280dec5217e", - "43acde052e75d7cf894d935c74e4ed63d8928f01f9eefe86a20b1a329f76ce6a", - "9d56484129611b5c6ea7ad5788168ded4e7051d5f363e2363371f4fe8f5c9377", - "0164169692e3e5c7ec98463d4a005f81f7855ab8292758ffafdc2954708919cb", - "74eeb814ba7abffc624b66028d57a7fcb671ff554d2acc1946be5efd23489053", - "fe73de5233c4d17c40cafbbe8880a9fb09b0a576b22a4f76d57fec982bf6b67c", - "856e943f18bfcfee776dc885eb00fa2149df7364cc86679d860ac5614d79d829", - "da14006189b41b61f882cd9ef4ab3f723e27fe8ab9378b1eeffc0c64acf59b09", - "edf0c67b7158e53856e059f46ce7c0b6434b8c50df83a727f66c6a235eb11ffa", - "984a1342fa6d9dcb1b308563e95fb2444de6c81327e71a3429100bd05157470e", - "b53a0b2fb117e8c4cf8f5e00a4b1b85253e601c54aeadb178e46442badaaa3cc", - "5d7f0bd4487cb6abc8fff3ea7da3d4653abbe45fda609f100a38ac35939b04af", - "9ecc9fb37c5c8b79b82cf93bd03634cf14cf2eb9842e30dfe4129d0968166175", - "98907176453166c43412e64ec8da624de18d8499266855ae90c45671f18cae48", - "d7added37da412f48d7adbad96051c5b0d41c75c1f63c21e829913e2a4e48329", - "72a07beef5551ca614d324b44375ea9f316a2d7206d26069490afc702c91df64", - "bf22255d5b3020dae0c18acfadb232a4a8537874ab0d5dc363bc6ad6d1dba020", - "11e98c8bda705c67ab21e0e8f4c24d6d1228f9696a81d943d1bb8ae2c209b25f", - "4c651ffb7da202f105659172a72a1690aa019f4578f702cfe457225f286fd39f", - "ffaaee2ee9d57854823f4124cb854628c115069a4adc6dfc40664c743fb9d499", - "8b38f9730d71e4b36697b82cd97806b11804803548206a1c48a9c20ca783bed6", - "4cf4706c169f998d4e38e28970d87321aeda31755be4cc0381bc2cbc6a6dbf6a", - "d0a996596823558b8ca374fef9ff332b48714cc0ed34753899da95169a4fd6de", - "3a9edfe54e08e4babd3f0af12a8ec211a582fd432c8cc62273122832a61e3f79", - "3d25b3c94cb73f025a6c7ff60af06fdc0c96084ed653d826b43b259a9bd603ea", - "526af906f6c94f343d1670a28cfcb73e56851caff4b2a7a09caac4ed3033ff16", - "396cef99d759cfd4277e725a5234f033c3bb0e27caef3cf2fe60e3f2155a0dd5", - "bef98348ff5eb417b2b0f8c650e77dbae66f88b966123db57e8655f6c527ff8b", - "dae5c605577564bc2ac172dbe10a86394a41f675692ed78a386fddcd485ef919", - "d47d1efc6f657fad46ec2ddd804c10f48a6e416dac9c84edf0e729cf98661eb5", - "47119f6a82bdb3b118d0434189ed77cf9b8e968972531086ca1181fcc6b92d01", - "cbe8f209c03de3fe2a7ee13503a0cbac2e7d700b5aa8a685a39f6d5ae40d9ed2", - "eb6cf81b04b2105d032d4117d5715f705ebcc7835c0409441ffed7713771ea14", - "801eed48e6c8b8ec7b44dff7d075f46264ddc04cf6dc13509b86b5cd4da10a9a", - "4761927d0ffba5eb831125c53dbb733c21137f25fa4593bd68fe25fb1bc26739", - "2549125eb0b359117dece06af56bbd2af312a2b207a2ec59a4c2d278ee3bef27", - "db1aa64ba3fd4922484abaa8d5154e5d44eb1f487554f4acee789e6394059861", - "d91c100854f48dc365af2edc0964733dde4cbed88a4922a63840d42bedfea5b8", - "46e69dd777810b0e24e9f11681079c8b6d0078ddfd07f2e4f9f6e68d0e02a9d4", - "8e8523c5b8c5824dd2bb23f76c807a7e50f45306eb935876ef9044248614bd88", - "6b5ab9bde67967b20e728d9e077170f57304ab134cd018b146951a4c270fed2e", - "88cb8c6910dbfa9bbdcf58a96427eaafe55032a855f467f7fb728f7d08a2ef1b", - "5bf125288e9aa62db1c5a95f56ce517d7586f513980126edc6bd0c1b9f4d73b3", - "d36f6779418e723c6c6d01a202aa1e0acb51398b3e8ea0b49979128154dd9778", - "3a97f923eb707fe378c0fff18c926f52684e911cfa1f4701a50d0161cb06ec9b", - "ece19a6e1d4258b27121a94196ff5e050e6f99cccf113a98db067df632e46e4b", - "5651fba6d3e1208ce54a3cc26e6ee044cd9fa3a303813d1e26fbc31ecf8315a4", - "46cf4369bf51dc148565a5940876ebd12ccbe05f29db51e1b2be6b862d13dad0", - "80bc19a2c8de91bcd662762c867e9588194f2f2aaf6013dc17013b88814fbe70", - "161bf78111ed14e069e194b2555bb91ebfdd6461bd975af959f4c337a1c95a87", - "21bc2d66f0ff51f2a9c07abbee3ed9ad6874c0fbc7144a7d1493e7962cd27682", - "fb4123cd06994876f37750fd9df4493e731de71bd537666efbfe532de608bef7", - "6fe4b0a5256ebb9d8872ae6a08e2fa0d822ed29ffd9e326130264593a48758d6", - "b77c8121c912ebded966ded25d54724d1bf37f49c5ecd8e965fa62da5fd17fd7", - "d4545ad0ec7bcb5b7ce0915aea5a1ff4831360aef3e462887968802ec65f318f", - "d36c4907ff019cbebc33597eb78c99e23bc085fa1f00ad4c6b603ae434335817", - "11aaeaa8fcf4f548683266bc415868603bcd35f17519b14aad55b5c4468dbc6c", - "5eb368c786bfad55b8fbc19b84fe3b5bba73fb86e8df689d37d8d767caaa0d4e", - "c2954cae05d08989dee15b7cd2782660b0b0840960d9fbccee013ae29df2e80b", - "49376b645220593b252350ca3c38e02b72e91901eae6c38ef9bc724c942fafc6", - "5680080c312cd825a60440d8dc550e4f6df9f01e750df2e65742af675dd4dc39", - "21c05cd6224fd242758f784507197aad044e2a05c8230633c9b83826a5decbda", - "8c0cca556e5b11ba3577d6bf03768a042d4174121074c3a908d806e883c2a3cb", - "3f7c1234c8e471e64a8c3d917a08ccefaa8e30889979d971b9eb31fb0ec15a57", - "ad5a3a82f2aec53a5b49626df77647bc472828ba22d9b955395a5956900066b4", - "5509837904cdcf4a33660b9f20f5adc1bfab049fa4ba876dae6344fd1c3ad2d6", - "5e64079f20fe9963f2d434a3b87b2f8b660a9cadb873a74a09cfd66f5481d90a", - "36e5e25b4bbe8f657be9105b010a6b614908880e9ad02f030d68661e7e9b4d19", - "bd2ff5eb86e9516b09f3630108896c8a1b885959c10061a215988f27bd133b6b", - "16f43c14d2338c946812ffaeb39009b103af55079a888e0f359579cf201687b4", - "4a02b40996b05ca77f6014b9ea3252ee6239f0099e46e53ab00e9b6c88e68774", - "aa7f4a48a1dcfd3047e94771eacf1477917193480f2c7ba0c319ea4231866f20", - "e2ceb64edffcdad59e6318fb0dee735778459f394c7a20e7d49a2d4de07aba24", - "e4a9cca821a218193777af92e9d53701eebd7f54aff6d20ca1cdaadbfd2e46aa", - "4224bde85389bd9d55b838587c40173e082d12510e67ab03b89732bd65e1da20", - "f085f030e2c3a9c456ccb81ace063fa2772c9d5848432d3d01ebe579bd8391d3", - "46d41311a2a57f0f7f6090e99762d8a3cdb94b64dc939e9e43025d823a8ca601", - "9a3bdb82706dfad47e4917e963a907fbb7795242d5a936089f9c2260fe01d78e", - "ce98d0cfd8379fe3838279c222b498484993d1484c45a369abbfa022b3da7288", - "f13ebd54aa52168a755f787cbf8c65d94263900b17758a140b66b33cb82d3ffd", - "363399ed6c52ec5c34f225014e8bf1e01a38ea8f3a95feef7f9eceaeea5d360f", - "0f2fe6a57d441969eae84ad2aab5ce39416a359c653f5d7cd8a9b0e791cb1648", - "6735e7ac54112238096c22aa234987c00f2d7d74c6aab221f99f9e8407d4191a", - "a29999f1a44e195f1d072317318dc13db25f07a58eb85c2fe2f092948953c3d1", - "432ab0e372c432a56ef7512fbc33cd54fbd13922f922de0791419c9d4099f2d9", - "584c138cd7b5990e66508053b0b4ac6142f209fa0a1e378d285f94fc81104092", - "5c1c4f852b1f5d00f47ce79cadf83244ee3b1cc30407827e92823184f512f824", - "ad873dca7e4591f1e7c60cd93c4b197b03cb58c4693dbc4e01eb4c98cd0d35b8", - "b6789e7e720442c0bfd46f0c71d1dda80347163e1697b4cce3d4ba42eda411ff", - "9a82521a80d360b889a9087dddbb04acadfd3950f87bc35cf98c914aa32d7836", - "25c49d87eccc3c7491b23f0b3a3848054a5d5335e05cd2e92716ddd295689695", - "43c3891722610bf7dcaf2309e45746952453f8ed577883f97771190926116394", - "dda458ffdc2a7eededd7b77b91de7286b2d9af23d05c14b410e027c48be22fb6", - "d4ae3b206ffd10eaa165f3b1ac3473de20677633bcf5d2b619b35e94931f4495", - "7b5baede60790e429ec00813ae1a9d2f879b0f724924d687586e5c7971a2942a", - "b24e5ed56159cfd7ccda8afea479c4ab1c872722930aa3ce47ad3414b3f307ef", - "ca41a582791483a9e5b2a564ec3c6cc07cb6ac9101a38280e76cdb549b48c99d", - "8a95d5aa7533f3cb2e3b18a3113770f1c4021ffd3c7e0d34eff2a09f846d4b39", - "739430c9aafbe3b297722162c980919b33f4b87ace72fa3a0fc914192528e7b9", - "29e49794dbc14886846cd58a8dd1b4c0435513dcaf0fee57a62322d0614dd1b1", - "a7100fb4718c0e91af3395d984eaa4d07d679fa1d6eddca09d190ec4e20c5e74", - "b43b33f962b93b670fbe96d20cafb2bf00bd504ebe5c57471365f129e0ca36f6", - "112a3a115a157405966debd13cce047e9354659ec6c1e044638225f1f7b51605", - "619008218ab1f6386b2a033ba607bf30da5406cc8f4ee4c34694104ab079ac76", - "17f6649d89e8e72912c6319c1aeeaabf1fdb048e4dc99ebe3578c85e7fe1211d", - "33145d1ff5845e1d1bb2a2f2a9fa11522c6fd7160e68fbc90748286db13a0c0e", - "35612f5b5ac9d7181d9deda10ffccf3a9cc2ae7661c10d4e45d3940e1b1033ee", - "f29880c8f1b7df605cd8ce88a964ec161a953d1d31419199fcd3f557670ff71e", - "331b3f16024275a03bff3e809e9d6b9e474dd1bef0bc400093ccbc4cd980bc29", - "4e9aee1ad1b9e76d320c183523cf4704adf5866310a478122f2190d3bcdd4b20", - "2c1552e1a9ac626ebc10a90c281125c8b2121c39ee4841d2b5f3d90ce1da1ae0", - "49acabf0ae6d97b8dde81f8d0c6474908ffaa2268130533b46555c5a5a12d95d", - "844adf2cee6438032b27f8f9f18215514e43c3789251bc90bf8c8c4d620310bd", - "5370fdfc43bb761de434677b88d8334fb14f96c220501546b3b5ab540a2e8b19", - "65c632175a7a787d00b81df163bcbefadac0f5f0cc66b145c62671be3f6cda4a", - "6d33c9f86727240f45b73adbfbc88fb13ded3f944a945840b04db9ca08d8862e", - "c1c5ed579c20f4661f6f4d1e30e0562c43a0a2a21c6a89c963aef32b933fd342", - "76a62702de61b6dee04400b30525648f6636b6ada435097deb68888a404941b6", - "024c27fa3827314578447f812920b4f4ce60c446bfcc234877b8aa7712c518e5", - "0f885df8d5386ebb88f513d77b9e9832d923ef61a64f8c1f95db6e10e3b66f3d", - "db2467f6aa334840b0c4eb89c0bcb982d771d73414397800aeeae4c103536f62", - "d59029d264a77d63cc5bd739a339ad55e139efa4277deb11a9897107402ac8bc", - "4d3a83bee1d3fb74640808fe6ceb3665479f8db1ebdacb0116991b10198af85c", - "0ad417f76f19c7c32f11edd7df872ef1ed4fe48a3890304105c9e37937237eac", - "8067039f3152a96c04621bcb58d9cf31b386f7152b84bf5658653df182f5979e", - "1a2e2b0c026b4ab88b7cde85ebcc7ac4a1014bb0c9447e258fed7dc36835e26f", - "61749914e621488b293b386911ad29493d5dd8ee32b6d81d0a436d4915e44974", - "adf51a4da26ba924ab1d8335737a0cce6551594c1a42170e5f7214c25028f360", - "5310e7806daa13a4d520f0ef68830c3575c939a67f9457df936965c6632416ca", - "1e7fbdeb95a54cab77e8bccc1140825671df223fb7b7068b05410c7cb3b4bb93", - "04a210521dc23e6222d8ce290b29af17e208cb2536830c66b91e507f0aca0a20", - "d92f2181cf3e7a1a9b4a79f7934f06444acab413f2a237b0462562c79b144395", - "1f0238428f8e693ec13b054201fe7e5ab9fbe56664303ed24a230ae7f152982d", - "39996ca0fdf74eae74e20ce127e94013719845553ec365a6ef2777ed9921d12f", - "96099895102654b46871114a2563589a817126908a4e076b00a734ba917c7e70", - "38139766fb4f268c4e53131765ab7a1f52c47f2a5526109c1f211bb1c7bd3fa5", - "065d3e90fd920cb5ed569627c6df3a46acf07cf953d6d0c37d6ad11f41cb648f", - "151f5839993d64284c6105cd31e7aa859406ad55222b3373ecf467ceb4f05b06", - "6ae4d67232e8903aa041955cf51409c2784971ffc5914a6dba5d9c06369eb2dc", - "aaf2bcef2d83c374900219812336b1a1b0467a7a0a43982a7402e6723486e3c9", - "346dddf2dcc883c25411fcbd2239bd279d35483f98f2747c82251be6952f006c", - "0d435a92fdd281348d353c18d02fc4a2c0a158d6601a07ba544af2075cfcd1ef", - "3a55da476665995ba58211513a3c5d85bc1ce5809af0d9e2654e06724d201956", - "f85e24ab68b6cf7a023caa109d29ec149be374de6c3e3a4efc6977b6d198f396", - "ed3e0f7c902b8452d5b5db74f027134e24cc1bba1b98c42e267fb057db95ef5a", - "dc2102e715f1b7f0ab96743a1442bef3347858aff1d445daa048c2fa2d8f5ec9", - "6fdf7cba8fe8da2ee7491f074b8ccb813f9479b7939755a5dc04677da8987468", - "73c21201bfd7b66ecccc0a6cb0e0605d52567a764de28d0e78c65277a38a371c", - "40568febf08d00771f076c0c5591d4887625b961fe8ac748247f962c6648a6cf", - "060fa3aad1260fafc724de036a60f7775757991d5d3d74201329f895de9363a3", - "289c0d763d3daf675b164f7afba4dfedc6e82c0f4771447fc3cd8bd8d3db8560", - "7762a7e19fb6f1bda7c2fc1774aa324ca5d2920b633432974576ac1eb9321893", - "23c4a3e242b04dda8ddfcb823a43e8cc8db5e3062fdcfb5b6e59772efd0d898d", - "79483f67c73a0aa603a5f651bc0108d066123fb4445dfb08254ce3b422a0683e", - "085f6902d9dea812b671fd043886a8def7e5babf7aee1557531d3c002a4ec5f1", - "7391e7480d1251ee0d71da65aa20f4bd0cbb5c5a724a9a32fbacbb76b1e6ef58", - "b4831bfb6eec21138daeb74784c6ced7b8a5937091d28d0e2b257192ef12796e", - "486b9783f0f7f86eb1aa75417d0e0ea3d00ce6b1418c7aa92c28fdaebd9053fb", - "c9dc39b3761161f1f6952e38fa903b5e526d845e3bc1151b283ee5c1638b38df", - "e14a243a4be058b06117b058f2975422cc5f007068eab4ff08f125bd6c70e9de", - "e001cd329cd53f3bb0cc1ae01fe6e8af8a5dba1400e4b4dbeddfc723dfc1bcb4", - "9ad4888dfcfe7ef4a7fe15a279925c0a6bbd9b13d838663d0325007bbd1e1186", - "39bfdf86c0853502c745592cd23bc86bba31ec9d28b07b2c245bbae9e95f5bd8", - "77194d637117fe17aed395c541889de9e2ba3f797db3f1d4d3455a15068f83a8", - "cb7909a46fbf61bd1fbf0fd13bdaaf103526d6df2fc1e77c9ec6f22766251a44", - "ea5cf2a10103ab5a7f9d27f6cec7e1b1bd6a115afd747b5d52ca4b8cc852b038", - "7063d69a3267f46b285b9fc774323f6cde934f90de454652f2b059f310dee526", - "9570fb7d4a45f0acaee1d85ae48c1afe33b0a093a489646c5c9cd8b03760c4db", - "5f140a61dcc085d109714bf742b291204872797bef759f11885c98ea96a67f56", - "792a4344ce23891d9f7cb111c18b08037b388e4611dbd69581bb6e55c0c15e62", - "67ddb64523fc4989a514a4420e82a5517a9fe69f93ae598dba375306fdafee79", - "32712730148139c1c66232f3c0652fba2f7d5e11bef920905b00784b49677946", - "fbdda40e37df9f8cf295243f2503c285ace98b09d78ec8025fe8062ba216fd8b", - "b671a78c80833d9253af13ea85f85bddd25c7332708d4d4efb18d2c3cfba1cd6", - "bb4482238a7fb8685450207f4d0d978a41428b06d0e048bfef207d092d54ba0f", - "a8c357e7bc3acc984f8a6c9e3f8fe1a8919c8f5e063d2b9ecae26ec1b4f536d7", - "2c6be05ef0731869c8ae74229a9c8a13f266d6cb84664d653b366a35f87eacd2", - "fa23a98ff2979455f251b5657c91873dba5bb06f2ba37d31c130c2b618a98b61", - "2f737a3ccaa4c514b557d911e65f5a725bfa028e2636c6b013a00c5dfbd35066", - "928249b3e58841791d12a28afe845da9bad60c0830c3495cdfdfac5a6f9b03fb", - "73f0cfbae24517945df5e6889c9d4b05eb90df833bed9d7b6b5c7f4a5b3f2f20", - "47c4d28984bc4d44f333b04d5ca5fd97c74064bb79c1ffb79f3ba7d7e511a940", - "d40df980b355b762914b452c874bd1ef9c52bb3df7d77862c1614dd32b394d30", - "29aeec6659342d809691cd69ff4d9bc8cd0342454270672cbbbcf3720879c1fe", - "62dac10031d9e9ec1bff4238f03948f9ec72599470aef6ce414b8633d7fb3baa", - "75e404b815c3e989255fde9a2ada2fb74e29525f43f4704df4146b0d41f160df", - "ad7d18c6453e8bf5b9a754741b2a56a3a5f2257c5e7e86f8153d50b92c697a5e", - "4813dbff737fe53f04e1b7ac135309e02b4c5d46a07ef026a5581545c019f971", - "726b1f508442ab9873abde380debdf56f620ab05e088ba31d6f3ceee828a36af", - "ac3f97b1921a6642616bb3706a88a121683b82ff09c88b8b83755afde8404a21", - "2bb05c88ee72cef3de0a7c950789a3b4b04c52aca90c1b2b3096830bfa0a7439", - "ff2c47d9dcc6bc3d0bdf18f26f34f64d17947229fd8cb0730920c4e5e9dffd4a", - "dd009a08d95932405c84556df226d87668d3ec9986e7f65d5f2666fbbd075b2f", - "9cd158fa2bf599da05b9025ae1604f833820cbd8177769f130e6c549728a2582", - "fabe7f39d9890f3d945db8c8e1f787db76cfd9b4cbdfcbb796e5a1f9c601a0af", - "cbd4d955659017ba5d199cdc4640f3c8345262f577ba49b9c0455ecab1a65cdf", - "fff7bb6e6f45d94d9ac39bf3a2e10df0f00c7c84af664bd695dc91319a0c82de", - "2568beb5b65ff016e1d71370aaf8242398d4ef4d7dd208b1c99f0adca604f211", - "99c9ad4768f5e51a8ec0519b6ced63315d0f9e0f2f5ef2eb605ad0bb054a85f2", - "794a573e13e8013eb755f9e5e6c5a4671c283b59d87fa4cfe53ad713389186d2", - "cb4ef3e3662ad2fa9f46d2e766329387b86f5a5663227c1981726f4f2304fc66", - "9e5f52713acce5ad528b4472db00342761884eb40306211a9f406aca5e9a0d4c", - "dbf718927114feb8f52ade2fb0ac783618fac692ea71f77b735099240b0d9c55", - "2217b4a2a8016a1a9e459ee9e2c8834bfa73215a9497ca1c588018e328233c00", - "7238098748b0aa289c389e3d5ab5c3569d0b2a3f3a525d2720d6c7d05509dfa9", - "d06ffa21f97a1a36417aee030149377c572ba1211e034653854d9d369b3a5f0a", - "48487a2b8705a37985a77f6f514fc3d45004a391e578b019bf19b7ba700a16f4", - "2ddaacf08ea48b9d7e85bb33e50c82843b9d88ae17079f43bf4d7fc3cfbbf828", - "f1c7e4a6835585ae7552ae33dd0389bd0731dc1ede703400c285afd5d3aadb0d", - "6201726f46639ec1926fde3c0cac71b879327bc2be8993d846802e60afa90116", - "9c6220250462a07155e06486230852a55dd134221435b0933778ea8d14e69547", - "52107388117d91bd94bd9b9af02722491c0f499ebafe7f5433d5dc72022f552d", - "2491393b063c241044b31c8ddb42b0b9e694ff63cd01c6f4cd8abe665e4a34c7", - "a1f9cc9a2d756ebbb0c55537eca5452346ab80c902b2423d8d040a0a04f70ed3", - "b245ac0ade1b66e11aaa92e81f9cffd44f757cef6e98e87d1747ecd088c9fdfe", - "322221b8d53452f5a9c84f09ce60d85719dd555ff7c5028706684ac066272557", - "fd7a91c83de883c55736799afc1860fdcf3c1068d1717af8b76b3862538e2f41", - "5ba1170f36e428f3d0ce389bd894cd5639241021b79c9eabbdcd9346b56ef680", - "82e5f22efa0d6bd0807c3ef9e7c80ba9b99450c5dc053b8ff03941b2c2cabc74", - "90cce0fd208106f9002dd05f3bc976f1e1501643a7b5814c2306418a9a0eea1f", - "51ce252eb1b8acbe0b8211764245dce26924e0b1ec21a5bf88886dc771ad1e11", - "107ae846370d12307c294551debf9ac673264617443a6e85cff045dc8a030ef5", - "98630f4ca3e53d2a0b78f59532451ced9ceff5391141957f6c124f47be0e18f8", - "82e8e429e3940b6a05258736fc125406b81bf8b389202ccaa6087ccfdd6e69ea", - "0612a2b7903c03eb07320a734fbb5bb8aa7715a6a3180548063fbe295940546a", - "ce17f1c7a762c88fb85ae86377f0b4762dd134a44aab16075e18fb12775a5301", - "cebe9f317719eecd5ea06b787a2f8654d31f2a7dbab28ebd077e55c58c0f8eea", - "a8af5f008733854f9d843d5f16a257b8c7a9796eab3d6c48ebe63cc363b5efcf", - "4b605e02a5637ba5752a03d19b9fb73bcef3a14a574324a22603a4c95b176a89", - "7d1f906d5e9f3dcdcbc72e563fec9f2f678616e38cca0003456e883d2d5ba586", - "a1f5de8504db2adb9e82113901e46078979b1021d8e604b5139aa890b14f17f6", - "7e7a0a9808e0404c22291b94f0f2a040dcf33feb2798ec6802a844c7f97297b9", - "4bb1165ebb0612d2608c9078a6b62a1d060122e6321e4e542efc0cf032e8d6b0", - "f7675960c56f78599501e6152b6ba727ce4b93c15567c9a4b367f88357555f93", - "9a0e865eceddf932461af97bf91e5b032ba8bb27d2229c4e7cb2a39fceccaed4", - "638c9a7727c6f189edabd86dba63c0394be9846fcd66fa1e744f2604265bb182", - "9e6ffc4d621b7a14383e4c6cf3819572bcaa8ab4e2f22a0fe66190963ac9ae9e", - "af93816cd4c0b5bea6e09829f0669a045d49f106026cd56215fbf8144ca95f28", - "e1cf3c8d39771156c5b8b1fff44fe921d021e57fd8892c7454e23c1153908219", - "8753cd7ae1aa62950edb302645a5106c70aa9beaeddfb211e814edb0aa55db88", - "a369d422d0ebdae68bdcbacdacf67c31243d8a3c05b7c84f610bd384ccb53a50", - "0b4d389143220e239911c2873c054e43183844b52e345449c8bd1c57d56c5bb5", - "09a5c90989585ece2a98a9d1769494ec585cc775f2ba9cf694b7f55f61333eb4", - "128275c56eda8b4bffae1a3751f2db4194a60d64b2f574c7fe5546b1248bf1d7", - "a92bc32d1fd757bdae9871cc78eb892d6a878ba1ceffbaea7921691fd1093cf7", - "db3a53276c63c7d001664f0692cecbb18f3ca284f011c45e14d04c63d78d2bf5", - "3c9c7da14bc8ea9c4f4717e62488ad3b1b585ee627d5ef4d5af9fccad632b1d2", - "98f989b582dd598c59b8f6c1b95536939926fe300b06ead9c002abd30a447a8b", - "f4e9af9921a2f014d552f5f77d78ad2a4b9ccd35ba45d630ef7296f04acb440a", - "e6c26024a633b3ae43a374bcbbceae7dab533d4c26ef30518e13fee562091948", - "c8227b877110655ec557e4a1ee583380b12fccb5e5168aed6aa6c3caec6e9fab", - "2b052cc979677cd68f5ea067ba0b227d7919fd72c64f72b68a35fe1beda3952b", - "cc2e20ccefc28a639c2305464d374fa99023e7b3f9cf1649c9387a36e626b761", - "54b7eec4495b6e98bf7e4f9ba7119aefe68e01832382e914eb6d630a9520a5b7", - "760e7b8cbc6663986cc3f2fbb0400a88a792a69044f879e4727e5b46e5f826d6", - "754b3ad000e135a1356050ac3b314fcfa265fb2b37cb04bc81ba268e264c5e9e", - "da85aedc68fa98a830b72d5a6b75b6563b7a776ba26d57061cdd000e8e806cb3", - "5ceb246c490ccedc3f2e68d1cf23019a95ac93609ff74dfc08bc4dab8ff4c0e3", - "8e19e4183bee9dd18e473745b4565f9fdc660abdf08767e7440ca0617d78f2fe", - "2220faae83bea930cd0ac548fcb08a73fd3c781e91811632988e82921bf5cfbd", - "c57e28ad78d428ea3b0c0eb0971397707c2ad6eced2016d1dc3de91c0dda59b6", - "f41b6cacdccdfdbeb6001960446607c8d51500e2041ba798c3db6d03c9d375d5", - "4c0dd9fc52190cd046687eb230ebfcb8df9108f66dd103d27afc907647b32cb0", - "1e5de86064ecf4b047164a14ff8b10fb6aba68dd321c84a39b823791ee524adb", - "b7e43dd3cf1f6a94480c8838613a5434ebf0087de138e120d35490abd567c6eb", - "dbe859e4a5810f16302b4abf140c79a7c0e6f5bea7e527c79b3079203d3bb7b3", - "102f1494cd09874ac41e20293e4f25b680fea66f9a404bccf791262715b054db", - "7966a156c9c0e210dc516a1e8089efda68fdd35932a40912de5cb05b0c702def", - "32f6fd7985ac21e34e2348b58bb7179af184d6af2742384878cdae4b26cfe33d", - "c81abc524408164d1a54752c4e49f2f04e09baa2001df3a204fc3e4565c60ecf", - "50955ebd311d12a7568a1eba98be01b3e87f2c82be2c6ff3acf482b08e2f0532", - "bb8152ee0e03a7f56d3857326eb8196ba0873ff8bc27ccf0329cc876311ea290", - "9fe3c67c7d05b6a9807e7dc398b3e49d8383f74260aa3e00239481b69870f78a", - "254b39495fd1d8e8a880742f46dad283bdfdf9627f95a7a5b6ea741468529e46", - "09c7d5644057afa8454dbc87ebb8c2bd3881e942f07f0f0041ae2752cef1870d", - "854e6856fde2e69feb3d4a18158ea178937cc4f34dce75d330bfffd11cfab230", - "bd6c53747a9fbc66f42f28d25dbc2e69263d80bba44f05977bb8b07c8a285dc1", - "a940de9c40c7a13dc7b82aa44ba1893bbfc24d3bbe1d3f8d824870a26bbfc812", - "cdc68eac23cb57038a3d536c0c4defaa18ea4c2c275e9c9db6be4b95b2d98ea6", - "44e4dd07fd34832adbab24780d12ce0950380c12bc148c585345cae1204665c6", - "a067619bfa22ae8cd56894c5f914350be36cda4ab95afd8ff526b472a5f005fb", - "59b301e09a6a78616e57c1ec3b1702d74b7149e99b57a97632b41e844bf0351b", - "8b2124e1b1c8f14d2ff066afe76d9f3264fb908c9257a51b2d951fc700d4e0cd", - "d346f85d2df65c91d9b7dc934b1b93463c9d54aecd00447d1af354b65fdd3362", - "e8339f595efc1f568d399b48ea182f12022b117266afbfb6a219002f21eb13eb", - "81ef6fe8e30e406c4436a7056452c7bc27fe835719e039d26c9772c1ee90941a", - "b62c3ff17de4347c973230bd2e7f884c3011e64cb92d125054f79fde32bcd108", - "7ffab5626a565e6e4df4047013d43d743c0045b73ef71fccdc60ec6dc61de6f2", - "38265cd14ca5dbe1d7a0c4e33f16dced690b32cd409890e4ee174d3786b91e5c", - "d38993b563160879ff6c5c1d4386f8a42bc9e4cf98e0616c61c0e7e8841f1567", - "86b4de48ef7c6324d7d62d235dce65a3ac39e253c5c7c0f6156e7b7dad6c9eeb", - "c55c3e8746cd1d0c08d60354c7804503b685441848ebcbf5e1d527d59ad75241", - "af77acb965efdbe3ab709169f9f4d4ddd59b0414941e53a467db4310818e0f66", - "4ce88a04c5642d1045e15d3699b0660c2e59f75469d5903f3e816664aa3fb5a3", - "8eb05e10934ce5bd4f44aaeae637adb9d8099b698e87511b0c4e77e61bfd648c", - "69a21ebd9b0394b549a4b14779b58465830cf73eb5fb05d2d7ff136f6e845d65", - "8f409e794825cd6759a87cdb03887de38c32860a68cb2a2d94212da997949781", - "edb0d70b59596f1f89f3f4141e29190de75c55b54603453379c30ac73c3fd990", - "286a86c12d795c7aed46810bf1ab9bdc9e6e3aff393393efcbeb35102a78e4ea", - "ef8aba816c519f8bfa4b263754771e14ce2b51ebf85e8bf00d8718d76c0b803a", - "8c167bd5ddab53ab345703a14d5eaf0209d474d19a5e219edee8cb0790ccf0af", - "ed4423dd263846a796f12f7071c99315a96140908412e2442503b9ce9cf3e484", - "997c491e92575a601e5c99e3322b8d11955e09c1ee72534bcc7d8328ebe34343", - "c497f419c7ec7b0c63096fe4f2d93e82127044aa7df4d1ecc2978ac18d570c20", - "5100edd48d43fd051c19faa3c77d188a1638ad4512c42c7519b8b86e38a9fc8c", - "6e26b182069e4c13f105c04b1661f39807c955a70850a3f97166691549d81060", - "d3686b0799725e6364cdd046e7b1bb26d6a76161ca35312bbf4cacf4413b0e6f", - "8ca2cf2c62118fa6398e3cb6711e08752b355b475bfc1cba0f54e3689681cddc", - "a37a7705194704c9d66956537c387c6700acaef6171145d54716c4380b45a7bc", - "65938067da03d16a9e526863012c386473870f47df08be850d93d8d089fec624", - "ee4fc010addfb4a39dcaa2a43bc6e44c9cdbdafdd910239a8220cd6461b89ddf", - "1f1f9bc124562cf370f52a062d0110a58ea0f2ecef63f11eaceee17176d463f3", - "0e4f857cf6629bf13656412f02046628de621233f01593c5b7ec72a0ffa51cce", - "087b8161905af7ea42e9356660d316bdab4cf828d06834f410239a951c51d03b", - "6c353ec907541347b75a98195d8f64d7c09a71d1de9fcc4d66f447220df217f3", - "9e55522c9d2fd1ae118f484fc88f448cd192d573546906322c69458e18e94852", - "3dec2b7853ceafd6852e2d57119101313f3e8b7a613bf88418e0beb7a36e66a0", - "da3aea6ec7bd6b6ae22d3942ea71cce3655d87a1981da2d1c23a89956501d41a", - "9abdae9b171be8e541d0f079a30f0379cb8dfa7d57c0759c5d52c85cdc810822", - "36305de3413f7641c3f28eb79b6fee60cb8cde4960026174a37d09e0ce9a814e", - "05244d005f619cc5d136b47ef1efb34dd3e1e0f00d5826d7460e251644fe2469", - "d46b6b981bec4c979fbac3eb8b9d88779942e3d4081d731700bee0b69e4a720a", - "388c4bbb4aebecfb8547066ae636aed2cbdc954bcab3ec2e86d75f5ae30b9cdc", - "e8978279119ff02507222d9f709aea0954e2cc621eb85d58eca96b97c3286f9e", - "c3f51c1ffeb8ae3dcdd8555efb4302955fd814e3e8056fae0efd8d0a4e8eca34", - "f1e3d07d3c26a985e192c4e743cca769a8107b758a14a56e59cfd4907d6bab14", - "c43dece890a24d95326bd0a0ebce5a6dff6d83a361c485fb3e624265ad82720c", - "56dfe4092e4d059f18e12d546d71568214618a315810cadcac4b012e3b78ca06", - "c16917cd00989aa601c8b4c93d8aadfd8c58df3e72d77ea8cf4629f8d18810d6", - "8bea07af8615eec05c7c1e551688f8ce1813693619f196f635e9e74c00d4043b", - "f7185e4e717d3fc0e62a98218079a28e39e56a8d5231a5162790c70e6655112d", - "8edab2289c5e50c5ca6f9928cbf0850ef530c3f3e2b4f1aca79e9d4d91efc305", - "5065a6ba97b5bae018e075a88f9ae27d9303c4885f9d76f4795e96f6dfb5671c", - "20b87aad06573488fbac4f5da021832a8b90036604c4c703a881bc0f681f31bb", - "9ed7ade6b2026e21c3fc219a76733cf6291115a81ab359805250ad44add183c8", - "9d78db73de83019e8db6ef5d4b400a6d9a473c99bf11d25ba90f6c0ac49f34ab", - "f7f7a488c1e0419ad499ab8197c7e00f00ccb84ad11c06ee6085c31bf5735670", - "60fcfd934fc53f9c4597077708c9c8976b2739b19f658cf63e2d623d4b041cc7", - "250e4787ae11bc83b5f78da948e14595ca345f4a8c028d07529f4ad477f68e9c", - "b7478c83699d7e8cbc05e170567bf877351eced9c961a94ce26b782f63fedc31", - "66b200e6691433d2fdbdf776a3d1e971b0dc571893befb0af29b2c0d81dc9ce1", - "a3d85507e4e251494654f5b8a410c7f92729b8e1e4436a73caaf926e5d0dc175", - "d2b4984725e468c57967f603f3b00225f5dbaa9f8e221aba02129640e5df76d4", - "7081c47f6de0f2eaeb7ab3eb040fb6e0734e515dff31fc3670988db1e37bef4a", - "1bf9d9b8ab9689515d2fb603d9c24ab8a0a8f4af98b07228fc521273edc514d7", - "a6f48d1dce952111f5acbbe368492ce35985be1f8ee4dbd71ed9b47f28fa8829", - "76c06a187135d39a0cfa4f10e670aeaa6aa962a5bf44f7a09552b9525bb567ef", - "b44a51d9ebb568d1c07ecabf19fe637860337f83b7bcc2ed6988bc5ef1d1a1af", - "f1cf961e47cfa57d0cd0a61dd3e51a50723dd0f476990f1479d04fb38fcef02a", - "f6e2ef9160aefa44f0af915cdd79b23ba3a61c493c56826cea05776216157b69", - "efb90bcb135b482f19b988c747ed5047734a6308f9b979446f42f9eebd670042", - "bd008dea28e069af6c5798cb04ae18ce036240ec8ea0da51c94034b6f5e97c37", - "fef1bcd07fe5388498a43be6797365f3e4e281d180eae495367b9e00743ce1a2", - "98f3b4647799439e918b564617f15e9b353de26d0a547f0cf89423ed8aa8fae8", - "c2ee0eab3bdbb47039933a6fe0cdc550a5629ab1519b8779eda3ea02527a9b8b", - "83ab8860429d57b759c8e3119fbb2941c0ceeeea578f324b798d247be4fc1802", - "621c980b5a2014703d37fee5d1f9c992464d28b941ddae37f379d6cb34f10d55", - "391c020dbeb2ee1026559764cd1f400ea725588cf9b0164b459dee7603e948bd", - "c837ad9554dafe5fde40a1f169809765ce54f575b23a5ba7c5cecf83bc6f166b", - "9ad1a13e88f265e0796644edea48820ef87664db7bd27254581bb5c5c1291c5e", - "3c6b4ecf36d82923a923e19bb0161ba8139e177a512039284e370537018ac363", - "9ca21926397fd2c1a496f1c4ab4ad53ba95c88d59c9c7ec90554b56072153128", - "574bef7df9ceb959e3e3c9686fe32a4dabf8d52b1356561ac30d12e4a0c48bf2", - "4d206ea0b3f2602e5e3f68710f1ebc088ce77e3d62635af2d943494163bf5b4c", - "7dcf2fd5bad4198db733f3dbc9f2bf81d3e14db114d7d09b7bd6d8f91e90266d", - "0da5adba28a8de2b93a16685f2d8c28ccf052da078fff19e932dfe4a4792c0d6", - "8625ec665cfb2c3eeba97f823e36bc8cd14d34009fcfdaa16e91d4e9e060c266", - "c675d63629f5f2f0ea04853fa9ae14c6fa6fd2e715cb01f2393edb27263add1a", - "bf2184c0473415dd708975f7f1085b2c4fe2db889246da212ee1f94abca62c7e", - "7a7e9a39ad829a6b1dfa07e145d6ef79661e49279e1632cdb5e4e6bf341ebb98", - "95e971a00e383cdd4f4c8d142751859daf5ec25487ef9e05280fa59c050afc3f", - "009182e230b91f042d34b100943eea346605c86c5387e206d74b80e9a6548600", - "5dc2ca5fa5407258a57838ad46b94424862102a238c7e6630de424496ae58bf2", - "85e3f48cf133c1edbc42129ca4b9defc118598bcc938d407f7b8ebdbb09d2335", - "1a0a6fb7030c2bacd4dc41500a16ea2e04dba65452ff98dddcc35bab118ff81d", - "0c2ad50e5ae18d0fe25b221d4d8f14bdc15a3af5505ce392d7640f4b1bca2022", - "557a988a31a5b9d8d30b7960a3aacde587a54d175571e1e0afeb38068bb15520", - "9f53101d5f2e16e79c17ce846283752dada25733ffc4b6558ddb0d2a1a1f3164", - "e763f1ab5c795056f1f59041ac996db2a43a9af8a79f5e07af6878b5f1f2cf0e", - "dc3e6041b0b2ea9a2ebfe0b549f83ec7d971149efb0f99e18d9d36fa0569be01", - "b3f860e37881608f2cbbb2d76d016fa9bc921735d803415bf92620571840c891", - "31b60b45803113ea8e7309de8974830d1817c10a6c37030cdb8ff78a04ec00a4", - "e8597af0b9eeaf29c5029aa7dc81df6c6933027cc002dfbf885ed7a6c460f9b4", - "231a115db48548c5999962316b9464fca1069b20b5866e901447725bc03437e5", - "020b7c44092d45e747961fd0d33fef372d14c1faf70f2d1779d3d62d2945c2f2", - "95b7ccc2b16bb3a31acf4fc37b98fe2bb266bae1a6747a9c859280c0db4ef7b8", - "a3bfa701d183c64c8f560b2bd33b20c3b50f70a9a2c42cd65a3c8f6d92979b62", - "39be52e7e41a029b5a2b266b482513ab016c272b5e7c4e988992dd492705e67b", - "390b8a8c851746f0978629eaa953417c80a3001dfc758343d26440e6ee20490f", - "df755a9aaad54c7fb60acd391b7dba36b595ada46062344ac49cb4548c78a883", - "c8bf4f871617cabdda7cdbd5767c475225e2349727b07a9b319645ec171ae561", - "fa4a01119e4d95b46e456f8674bf7c11013c9a1fe105d517face2cf1fa76587e", - "e7c00d78a831ed6b2849ffaced85db9374e18e49e1cf30da8338fca8f52262d3", - "e2b4d8574b153756bfd71079e15878e08095849c0637efad1344e72aab5e3771", - "2f6139475708dbce0ff852a844ba9da318a990ce5618293baaceb0b38eb4af6b", - "967eccd40d779934916ee2cd34dcd6328f7454bf25d511bf67efa56a0b30902e", - "c92561fb49f73981ec49d3374fab2ecf952f4cc9e3579ee0cf09a9376f5cdd06", - "1562a6caf6418ec58e1269ac558ee3233c25f93a9f0a1d2bfe2d4875133fd282", - "7ab24dd482d63141442fcb5bddf2ffa6f850cca962b5f8da56c0d9dcef25b042", - "206226da9e87902126f725be503d62145d8c8ef0d3396acc836523eefe36e3a1", - "e1e206b758785bd85a65133b207fa131a1319419c06673f7dc852b1f21cd59eb", - "8931710c5698598a5cd7e6b2e3194264c886aff27fb101cb98936baa05f15564", - "9e6bd09e3aa9c77353b9ed59e4a439adc312b94ebced34da5bc0164cdba915ae", - "3f6e6b96a5a43e7628697e46988debbbd9b947c1d284b3d814a1519cd9e655d1", - "ac86bbc8586f6e91f46cb6cf95324d16c0b727f182784bb249cd26cd12efb47f", - "e3e1dcb1824d651db77f0add253aef2c6d7320ef89fffc0f73ae041572ded1f0", - "a96214f9c8af36c73f74d6e828728baa4e4abb8b9b7e3b501cc5336b478f61f4", - "a616c58ec9776869766ddfca4a18cf38bc371452edd08f191b5685d6e5f8e319", - "b8935c487a7c2911bc29ee63534e42a55c96a0178599bb99d26a402238d85c80", - "c6c8aa1ee0fdab9a9f5bad142130b6458fdeb630c9fddd710b74166ac0988f73", - "e628e02af1bdb36a5282ec5220e5d1dcfe224781477207d49aea417e219bc93a", - "c81794f47f7cc5804a4c00f00e190a2df7b61d792193730a174d55a7745c3276", - "aef8b55359c23b5bb804a7b04f1adb6836c9637579dde60301ed1ee3236996ea", - "4435fd0813fd02ba7c1bee77e31e64c2c3375bd2e8cbc40f7f14c078f7bfaee6", - "357758bd244b0f011f531736bd3dcc812db81198717b24d518fd80cd142612c4", - "bf32b3d85bb7457912812e3022a91eeaf16c68e4e861615c2f6d00215348aa7a", - "b2c93d46c894c6820f9b9144f8748e6da2590a90cd12f197d5c7db723c14cc17", - "a733111666dc03af6a2e83eb9a0ffbe2b33bc5346c43c88311d3767559ca15ba", - "c7b242f598ad67d839eb842d5dd02d4cdd117aec8c84742b8a2b36d830dc4f34", - "7cd412994502c960ce3c41f05b7cc5bbe078a300b69a193c06c28f0adbb3df43", - "ca57a2357420f8f520fcd3586ca18a886c55bd81445fa31e98caf8df310aebd7", - "5c392aa077797f7edb84874bb27337b3872bbe7e130ae879b2591ff8346c0f96", - "cbd684244936ed0cd09c5927e9eaaabd57862596ea6f9cff592bb9766be3a6ce", - "4174dd88435cf48e3038f0ede2127b0c5d0416aac2ed02fa71c88a2a0b568482", - "79d95b4cb551b841c88f16259f08e3f74c980cce9815ead46898a594c7191b97", - "dd96df260871f266676afb7f9f63674bdbd8e75be5a748dc16bfb7c752d8033b", - "9ded7e1145f61ed7da98a1d519f11e7eb33e8b84c819e39eb49c9ee73665d89d", - "6b6bddefc09383f008d6797cb2a9fe365af649a7a287e1b0990db042fb96f33e", - "7257699f76956c709f728b52b18e7a2b4b31f33757a6a8a1d4c9b4da40bac512", - "9eadc24cb612922f6a2a2749c533f88f03251b223646c6e553bf41b65ac0b2fb", - "f30243f46da8900e73cbff23abda6dd7778cc8464a586e15504cc50237bc8c6a", - "9ab3ff711bd0017b2e2a5580b83e784cdc2b26ed2e8a5494fc643e65fdd5af24", - "76b0c75bd023bdf8c41c99b2ed2910876671e18f7ad05bbe9abf7b6525ca7c18", - "535d1ee76e788d5b1448a90f21317033e4a5da9670919d99110cfa150a3552df", - "e04a7a775e4cd506813886ed45917ace5525dc72db8c974f54c7c92b830870e0", - "9de6b4e8c5f572460fe972e8330f5e713c37571c34db7c728f64b7117dda756c", - "46007700465071c9a113ef3dd6d1a164e8f4e954bd1e89f1753818ea15df4cc3", - "bcdc8e43aa3708369293218cc442b78b94c684bf06445db8f3f29695d998cba5", - "86bc7090cd02a1cac29d8e801d48776ed7a538f4eeec33b05841013d68065cfe", - "0ebf96326f4add2b5b3c4519e3d4828fd8a849b1118aabc08b92511ace768a4b", - "b8af5cd546c7936d4bacbb02b045e2433cdf259c33ada99de3119912b5856a80", - "958f3ca1deec9201f4d002d31ea8f229a8997b2e874d075bc2060ced078f55f0", - "d9306bb9f62bbea514e4df7c1230ff30bb886fa940796c8c214585f22808512f", - "dd443bfa55a59ccfa873ab91be72c10699be4459d8f2a51cc26da840839267e9", - "072963351fb540393f9d5b0100574bc1c577d6872cdede1742e8c4b438e615a4", - "fdd4239bacc29cde79fb0446675e1138eb74a620bc74acd20882ac4e71cd1959", - "d344d1f3b70a91242d30c551550f0d47994a74cbda0057c0847972d0ac72b98f", - "30fcdc0e9f6015328a41d24feae533ddb195e47af56b4de85f45fbe540994f60", - "44459262682b9065855505932d60e9c5d21ba514e20d808eefe3875feb5dfd4c", - "b1df09c2b22ad9c1754bb17d7389aca816d7d38eef5821ce955cf690f5bfc8c8", - "81b7da4b6beb9e97499cd86206ddfdd94b1a302739aadafa6ba83a186e3ef2b1", - "5a34dffe70ecfd882098cba7c542cd2d8dffd7057471e7d3381e6da8c05c7d00", - "947b627bcccd1fdaef6fa635c4ac906e55bc7ddfd190c61ab27c7258d520710c", - "302423a943a70ba2f1251ad938d0f27ebc28d7d87896ad5db55631fbcb87ae78", - "3dd22a39c0d916498178434986b5daea6eaca2136c649d84c38edbe34a519c5a", - "184b5777cf166a9f4970d3170e88a14b9855c477b326041a5ad9387695b3934e", - "9c957529526c545d8a2c7422e0cfb9ed8720914fb9c2b590ae3a778774471bfd", - "8113cf0a1d28590cddc9910b772f3b5c5cc622ec82441a80c04ba379c561f33d", - "90207686da47ff03dc13fa6f69f29efacabf69aae9d815b6bca9d31432d0a0e1", - "9bb15bfb406fb4e550bbd712a83a5d78c284177a0005d7876eeb6a0861601977", - "a8c2e5217bad0fc0e385deb3337eebda37f74ad7829414e2c5194f0a61c0ef33", - "348fdc39f1ccef382758844e8428789f8cb4628aa9ef2e89559bce728a2c43ae", - "23634a41b2e6c1e4a9e658acc0e6cf6963bf35c8e1f96085546d8b799b4df774", - "2be2e1d2fa54a96a5fa2fa2b2731327fa52539c089256f6da458101266dab5e4", - "5099f3c79f8a9205072b261baef8a5b5a6dca37f76e32ba083f25249d448082f", - "8e24bc53dd40549cdcc536445fbd6f39f9a5394c7a1c4d2116c05230a4dc04b0", - "4b992f45e8e5b0ada6ae9e05d1d13a3932c1a0688c2ccbdd1b249bb67f0ba35d", - "d55d2b5535b913ec9ad25064ede622dfc57d3c40e947b0247de29cc4b21ff349", - "de4b9445cf350828ed23f1a26e6bfa2e460021cc07388a35dff51157c9f0403b", - "1fbb09b7a876efd544b3244c3fda55cb99d2582d57b857b887a8916de262c693", - "1357be1bde89a16d7c19f580fcb88e70e3d6cf5838f60fab480fec4f7255dfdf", - "796abff22a991020b97218846140e0e25bcd3c0f64b242ff3b45048a23dfe70d", - "d94d5af25e35b2d25835164f8701a59ed56e63cebe0c0b642ce1cd315acff6ee", - "d531f86254de8a1733284f0ab19caa7ba15f900dc5ba7f0c9176b1ebc6b1ef91", - "dc6c68b9c70fa0446c01b80ceb7a219e3257eca71ae7c1eaa0725547736fd5a3", - "94ff806b174eac6f6260f43b947f7d73b45aecdef6a15423bfcce78991690193", - "e1b7226edd6d6475e8154f757b9b02c45750443518f38736986642d4d91bc2d7", - "9c05ecd4465421e226b9daf61a94ea7c5bcae2ecaedabe7e30177581d119faf0", - "6578060bd4e2484deaf3a213cacb31318da712ae140463189adab0be857e4a67", - "fcf1fe1a4a05d7c015919be0e5c3586ff2f5888c5e9ee3078cbd62b78e5db986", - "8ee945b6415efee0683e3b7a55b91f83fbccacf9e1ad5237f6fd3d36343f8ed3", - "f5779afc4f1aed280aecc2645ead30a3fa6262f234c8a073ca213d825369fbe3", - "028a567398beada065908b79f8a92799ac7eb667bee484fb0bf570d8a4b8243e", - "92cb8fb26ee43018042085cb98d710dc9db8cabe980bc3ddff340093e0638b4f", - "d379267f92e2ee67ab251b392a58b221136430da6299e6385be60661e28d824e", - "fc00bc8b850b2b60caf9e12291b0e446421eaec492712563cb8eb78a7980dc2d", - "d15fd1e595e1ab26e5ebd4fb55b58b4b712c39e54d7885ece2bf011869939763", - "4a7c2441db726572980c73e870a422cfe88a90f0d3b0ba9cca6a4a7b283d6da6", - "f9746ba7d2bf958bea8662512b1d032e7cf6d9c84a91732db98024d0d5cd5983", - "b266d772a3146d14ae731d34f23d8056bd8e95a4ef04ecd56549585c624076ac", - "90b535c5d772539b7a41dc7aa194b103c132ff5a53c25e905936f4d79f8e0b15", - "ac8736c9d3f94f65dbf96915a0b34f57a823472dc01b8fcf1aa09db90730e502", - "b038985877feda57211a188a7abc555fa457d70025c668c3b5eae0b900077503", - "57fe14ee0d9aae1cffad9e5ee4e60f3f69afa16745faf57328cf1a1d3534bc6b", - "05bebfec88f4949854a75a8d5ac0c99f820b075a37da9852524e5a52fe84f445", - "388cb3ae86b0fae054dfc67feec98ce98cae52db00f4567b3e4706f5daa27472", - "7d850934aeb39eb1683828d1dc09f536e42917216daa12c9c29c0140c083e871", - "c096fe483acac794b4ef5b204163f4750b6b9aa84d3f3ed05c63d50769ce2b8c", - "f3c23e9423ab342a6fe2a0b6e53d6af335e56a50cc917987e5a11c0e850145ce", - "c02326ea5956f04030c89c92c5eb679b2fa4c6acc1c0b3617ea20cc898a81d53", - "feb53936f5d21c3bc077b7c1e36ee814571cc7ca20c406fdda15f377d7bf7d3d", - "bdc5e5f1afc610f315855fb62644e057fd57db083ab42f37b8943a90e4017634", - "94a8dfa239ab31aa3f4f810161ff2b30a4e294fa842f4b38d48c7ac2a0f1b024", - "3b7771942bf0b91a424f44f8dd16dd0772ad270707f131eef675a3de1c9a8fa8", - "2b528d4718c52562d6fd998e3e44d732a8d1026a42aed965a156dbc5fdab59aa", - "57e2b6cd77aca0e04acc2c6741d390ea37fa28b302ae386d0a494b4aa5afcc75", - "81a1698ac10aeec418961e6730744b633febcf0404bf37194a4ba601bed164f3", - "d8ff3907d4e5ab88588a5ce1d1521bc0b026a14616b9fc3c22ec02b64f0df258", - "3194d36c217042033ab3d0e8ce56c296b50e50cd9a76d99903da9a1e70ed935d", - "2f71f8893fe1106c48c28ab6f2b07404bafccb968edf04757099f6313c3f2606", - "a8367e2642ee39c74b073718a8a58b9b9a46ef66692ebb9d8a3d6c3092786a06", - "b1f9b6e0a73f44e98c64e557f3c49301a9272c64d8448e8c654890e03f6eabe7", - "1eaafc67c5d5533a398912419ed2a80df95bdf748eef8e62118ff5c518d0ea5d", - "1720e088dc29f001227fb5ce768f93381f14cc0b037cfa875bcfea8b60edeb62", - "37501af040d573fec19c67dccca82447071c8069f4a5809c15787d8cf77824b1", - "839ba8117c2f491fcf905ae0577a9ff0c0305470ccd045e94f8cd58e88b24f47", - "267e039c628e181819ffb09d97b054693b1b02c36c879c4c5857eb12792f5d47", - "01cd507dbb589810e6dbf305134fd58d87180f1242386b71fb2c714587efc7ee", - "cdd29833cc4f11f897e1b6b74699a8dc86139d115811a71049599ad55283c847", - "4d9c60abd7d4007e923c2b2151fb1f704a414fd2a0dbc30c21e38ce06d73b3cc", - "2391a2ef33b8c805321477ca839c7ed7ef7398853be7d3a27f3f36ca8dc9a2cf", - "e992c895d68760dba75ce1bc415240c2d16c89c1ac4328c033274ae90bbbe75f", - "75d263825359bf0629133c0acf8b6d8d93d534978beae11dc0dc632e665d9cba", - "3d4d17d44ff626315e98d141a662c6b5cc4c8f525916a7b4612d116ada848650", - "944203a0b58ae14ff9c084bd4a0a394abac01fc28f5accdacec912363e3848ad", - "efd8e4e7e1e5e682c03ee2415ec6643beb10cc081956efc6b22bd1e1132c2b85", - "7a40ce773e0f96c33569640b5caccc1a109c1e3eb274b8d93ab20dff10eaf350", - "a6fc44ef8ac2af8ffb04bcf8acdf3d1062eeab61cdf3d4fda7ecd16688106627", - "d9846564ed348a273a9715141207b46b6ac10aad9854783e95f6a6e68648c4b9", - "5d5c0914259d0374f935bda3e1dc485f9e93e94798aafc1ee1a7170ab129a46c", - "fc75bdeea665bf8ba862c18b9166697a25af7d5d43ffa2c486458fa7e5892f6c", - "ca19f9e3c0068036060c680c4413b4034d418f565c6131939d29e7e640df0fb7", - "749966116655ed6d6627c0a8f43e69715a71521c484300006a6bd54f430550ae", - "7f239760ceb835c08f159b316abaae62a8ef04c17df9de994c495189706f71de", - "ab3aacd4ffce6f9ab8adea7d14ac06afb229519d747f4a29f52f492a8c64d46b", - "760904d4239e2096cc70dff39555879f22a5abf03a43ea15c7b2adf279652045", - "fc0b557814f979de978856014d1f3f14ae383a84ba56d15ee13891c158a5277d", - "7c8dc109fe55d484defa434673378ca3dc2ee76fb2055ef2873c4a04de985c37", - "b2acd8ec458be8928a4f72b7bc7fe7d1e65b5e1a92b61da77f1677ba2c0401d3", - "1077f1948925fd8785e9eb76e726104ddec0ad3215b31a4bd09cfb65a0a179b1", - "0f143aa07133cf19f3a78eaac213a69a973711255b2d14dbdf85e214c2ac2d01", - "6b12e2b47bbdcc3d5d8e44f224668baa821fe5c8c13df77d62e509f69a823f22", - "d2593ac51d6e7604a1269f729c05fbdb1073f48b05fd6d9b1fb61a50102f2037", - "a21f0869f4d9f042230bc322f4e6f778c72d9c4ef6df8f046c4e9af6b4519c59", - "c7f9fbd75e8f9289321234a2d7234c02b1cf02ba7703a34dcdf2ecc3c500058b", - "1e643ea8d50503f2096b614f05dcf25ad8fdb207d2d5edf9371fd2467baaeae2", - "f899f52380ebcf089153aed1568ece5f227397230fda9d5e2288d970db4e8900", - "bf10c15a4f02893789ea69b01daa254ffa30ba6cff6b8c6b6308b2b6c0e98690", - "721ff0bb74b2e5b3a1a59ce843b1259a5df99ab8ab1fc1e58ccad0b91050ed33", - "b0186abba771f60bece237d9fe1b8336cf533140f6421db1432507bb70151870", - "d62c8b2ac8d8febf4cab2b2e7e17a29e5f338b292f0a80168ece0bae898dc52e", - "bda8b5c2f2fd5e2aec1bf01142b68c8647c71ee796ba4343a771634588ca7c59", - "c416bbe5d84275c7a5bb892c1c29a483d07a3ab66bbd6f697997b1c5bd04bd1f", - "36a9e45cff6d4f0da668a615242c70bffe0daf25ad79ce237c95a661e70fbc77", - "c7017da0526a26d693de22e05557a534896982c3a5315d54582d3c50dc046860", - "d3c13c47f8f148545e01418d1f2ee2ef733a013c4453975ac407d6569b4e3295", - "ee647e0207c406f2bbfde093583b71b293a5772325bd64b33e4b74f66b7da340", - "b75b5df13f4341e1c70bf1aba2e739feb588e47bfe3664b3b2666138194b974c", - "46b0e33b14cb33ccd8425c13c83495a4a916865f6ab28fddbc8477e74ca7af1b", - "3a72387ffabc64319121fd6bf82fc292635a83d295ae0a86b0065e3a68b45cac", - "90471fec85a6b1c74a215189c40739e54cc70773e13d955cc6a96b22d3cc8b95", - "276ca8cfc4907cfaab90b4e19128a212122baa5f7ae6269808274318f29d6d62", - "68fcb2c82852fbfbb15575c03de4c8680174525edebb6a43077bd9af03e86826", - "fe44d9ca49b9ab941a135315e62159c9da0d07dad57016f4e08c042dd9b9ef8b", - "0135dce1acffe7f8d615bfa08d0a44c6bd7b3ba636d2c1b38d1bd89e8e870373", - "43c1b312eb844a794a19b34e290e8544a843c4f3338a5a48938406962d8c82bf", - "31e3f38d32ec42a81d87ca6c528c78bec644c4d07f54c1da9b720efed997dd40", - "a56c51d81b49f8ebdfa54f5f721a660d70f4ada5e6e2af822c4bc0bf98db5954", - "1b7994a76c776128c3075be74b033fd40d48b14f59aef66247fac1d276831931", - "589a0a56b277648f41c5e12b30fc7b989e4284c28af61949818e782781500614", - "d00ced5ed36cc62453c75a36d8bfcf0aadc23783e1b4453aecf0496a57b6751e", - "9866ec2bff774580c10a3b5de2ad9f72b4329c64cd5f99ef20e67eb99e0c9b22", - "a0458d454b60015b223edb7d4f0e69b1c021340e14e061b8f7b894d48dfc2a58", - "7edf38013100383a5e1b0f64bc75838a33267cf5a7d04e341680a1782f098585", - "26e0b5c89ba085320d53dea7138c9fee1a2d00eeadee3f3a4ce3e1a906bf838c", - "108b6551c896350805959032ca7fbea219346ee051a2e1f63883029050f8fae9", - "7eaa34889e8111de968d312cc81768766610a1dc26d38878a66ac1c3a425a18e", - "70cea918f98dc791a78d0f15d0674e2c794e214313fc2216d99ee0cfb3851628", - "4892d3c563530328b8481c2acf6c4265feaccaa1d5b2bfb1b9ca2b142d6bf36a", - "433932961f5ea9eef583ac44adb3b2148c8c410da001d0b11fd7a244b8c81680", - "f24d80f10342cedf86f51412554792c2bb048969f5608386a281aefafae485e1", - "05a7ca3458ddcefe16d9d5ae673c018d2c431fb687f9c7f61edb0b85df0bb874", - "ef70f2fb79761d227112c12915c91d8bc646f00fed29b5928db07876531ed321", - "d898cf1c6270d1c46c87ba44546742dd53ebcb1c5de8e961ca7121e5ae994643", - "dad70c6063a51fafb068ad697ebb866d652ce0b2b87f924749040fbded97936f", - "1b86f6845b96b09ac51e96354a6ac607853f5f8900d40364c4d09452718aa453", - "df9fc12db4929cd320f62ab7647193369ccc959262304554b34ec8680dddb1bf", - "a12673a91e5827d39b255b5e5e4870ae4184d30ed58253b15d5141e1b494d798", - "df08b85646ca485cc846c32722f0f3f98c4503ba3012bac41740636bd283a848", - "5747c326f5573a6b983c93b28de779e8c745f752820e1a1ea48ce66705948394", - "0605630f9db28de035dc8b3074ac128835157b3bce0c9197e0a3158835ee9aaf", - "37cc4f891a76586692b94b6b5d29edfb480ce686e1af44a409712fccfd426ce3", - "2f57fe8fd80620fa7e242cb094811c5d095aa05b7ac60e317cc8a7f191547479", - "aa4b2470f193326eb0f025be4a67875125782581379edca5a0aca7bcb51ea693", - "6d7ca9696468a66388f1183293f094198485ff911e01700834fd9ebb82998260", - "45c3d85699857642a9f2b64697977c62fa4c13bd355f8022ef56ac23803cfef7", - "6321a95fb15bc281f56dfa46baa48de819850c1aaaaf0f76b7aa8436861f0406", - "5d922f09ca06338a8b25e825d822138b0e48ed90abde8613170f485712a0eaa7", - "9af0b9fcdbbd1c767afbba61a60801eba47cee7780202f89a9c9b41cf9356685", - "91aa14affa7d54151e3bdb8c3b37309f08f341f063e57f9cd069459af07392f5", - "1ef0c749e627ed37cc23750aafcc3d781abe3414b63a1d8e544e51ebf7dfbcbd", - "f34ba9b83f4fc8a06b038081778bc70f0074c4a3bb6b827411e137ccff5ec400", - "96eed92e667cabad4718306a2cbf4095b0b1ffba14bf449b3d636096cb421cad", - "3af41940d591c0faa81cc7f5e0c0ba1438285fbfa899211ba701d41f6fa8f848", - "3e95c78000f8f2403e21d7a6ec52361ad5d70f12b0996d553c7e0a321d01cd95", - "af0c2fd58e16e67657ad3a417ab0359b4f39d7c5becdca039aba99d3d6fc269b", - "288c3bb314b4327fd7a56c4d82fba4d9400c868e453bd49f0a90b2b81ea84256", - "3b204f68c6efa9cbc902778bf910ed50c480bb8af54fc3c3d30e4c7a6609bb24", - "b9a3cccd006c42767b8ab2d5c06761a768ca8d2d2a31942eeb4bcc7d472c071c", - "7983f3cbd60252cc46ad9ad55b858e3e2c08f9facca20793c2c40c1de6c5f7f1", - "0894d3e14723a63e0334bd54bb8ff842e5143eeb691ba6c726cb1f13595352de", - "0196bc10427a36b28b98502cedd311a1e39ace7c8c0933a33b9ad03d3c897458", - "11b18df65128bb47428c3fbcfbab581e1f31ee2b76631af336504670feb1752e", - "12c94c4498090f976a6570d022095046b76bc82820a29efc3366d97595c2c90c", - "f254b8e825c037ba90a90cf511f0b271362a02a6b8dc270b9203aa0c3dff016d", - "c8368ceb6f0a30d7210e791061af49615c5bc2a18879670f603e92cae457c0f1", - "ea69a2e620b73728fb89054be3b2da472877e93acc79fc4ef87952b2728f0270", - "45e0c57ac9025eb18751ebe865d764aa211829e49e753875ddfe62d122dcad5a", - "f806e0b7d151c910b04f1987b457fe7c0031ee4c3bd7a816f4e6542c67ee6bd6", - "e68588337b0cb511325a71f03707d21c4fd1f2f207ef6607b6ce78cad334f28e", - "a13324ee8f43b7ac8d93d2e3b835306b9ceda77206eb3c45972e42a650c4153d", - "a5aa5d2192fc5952987a34ae83c976630b7863541a2416d057ea1869dc2dbad7", - "0561c60f74567e6029ead771ef0e93655493f0921c9fbd7b3aa37cc1add2cd13", - "bce4a92519d16a7453449f385c79e93ed929b542034189f95baed1fa63870bcd", - "bde91e5aa7948344f15f76d2e8914744b1c5c0300de7fbd137eec82f33668c70", - "0f87c9dffe0a56353916cdcc4b8ed88825e63740b26bd6323a2563ffc16466ad", - "b3b2a58ef185d4999ac2f81d3a41eae6ca2786e71115dfaf44019b545ba15f93", - "e5b95605f17b1d4136f618acb789b7dc25d663a74f53742854ad0df6f21f15c2", - "bfc27bb5b801db5235f96e6ee4845b6871090ed092e4c002cbb8dfdc0c90666d", - "571dca9678d77791f29cd2971ee5d4f7e50cc06cd4869752a523ad3f3f673535", - "925a055c2fffe807af1994d17a6fa36c4bdaf883a6f1a1465da82cf3e0773ef8", - "05af698fc837a31e6908e02cbffdbc7e1924b4ebcdaf0c252f916eb18640aec6", - "d8196b52a2f6b8dd8891abf0993df1e9a9cdcfc0526551790f7321c3b0863d96", - "e986a779e8218a9c4d35a2450210a90ef1332201e3c6f1dea6ce036ba2e0ead8", - "20a75cc268fb97e3b4fe230d4a9325b7503c1bca43d3429708ce1a7d91c8f629", - "337fe30992e300df733a766078d10644866d08aa55b6df6772d3b39657d14b11", - "595f2077535c0595c06b87c17ad34aebf079d7c17014eadcca0c32886eac4175", - "c19137b426d65ce56a0bb47f82bddc787fc2703980a49836ab1ad5538af524d2", - "75b61fd2a8415327ba6136485fc852e2388a6035987e06bb90daaeec41c71a9a", - "52c0f77d629847e0633ea0d4e2005d12ecbb8d71ea466908bb59fe59c5b44091", - "565a29c5b97ef6e38ddd823939b44c8cac6e950bd965d95650b2ab0c8ae6123b", - "a13f0bd4accdb0432a04e65c517bd59ab0cd43be97dac090a334d35cd5feca96", - "4235daf215ff77d101ed3a9be921c51df685dd756276bf4f57fe8f009985deb2", - "b145842e194effdddb7ae018d596fda348dce28d7fed96758f6de9edfe6e7ed7", - "b680fe2ff08bdb7ba90b5f9c085ebb88fb597c3f6e0f92e90aa58f48e4f8411c", - "fe8696ebf29080929cc720afb22d64ed9f3d853825eb1a13e8ccfa97f4262833", - "bf58b8cae7c9bb22da99e494fa6003cd041cf1b2c52b299431da58a19ba3cb5e", - "ecc595019a1da55754e8577d78b8b9bfa085dde195ae1a78a0dd2b6ff0dac2b4", - "2b054d04cfb6164275813e075c3e2edd20c070049b55901dc8f3d49c9ee6e0de", - "9c1f252e0a75480f71d9c91d71daad01dc1a8c8e9333b761cdbb62786f0ea5e3", - "0f748e88387f65a4e41a81f27f4992b37ef0b1b06974379118fb2b7356a6dbef", - "a570e9860b323400ab735b87e31ae4ee2b35c241829f4f705c9332818a927869", - "1b401734d2ffc349bfe022f7b8b17b8712052f76ae3e1752d82c34da8d833a08", - "9f32a7907be4e2bce8b92821d620b61555a3263af1d084177d9cf72a1b69663b", - "9afaaaec524dc14468046c99868d9ec72d251ba20eaf4970f0a8eb1dbac74868", - "6b4a9c8334193d275fc8be3dd7558efa7e6a902100afa00aac70b8ac67d2bbf6", - "a1c10e713c180192bf534a6e38d62226b32dc1a671ce21cee5979f7e4775fd4d", - "2d8e6f071bea40975e7a92020dc8ea83a9f1ded3d27a1bc9d27e92ad8f471aba", - "18d57a462ae1801c3fb7e5188e0d03c2c59dbbc28a5ef9c8a8e1e7d1fc35e15f", - "09a41373bd641a981e51c1f9c14065ef9bf8afaffd3491696067ba7daed1ca27", - "5a70d9b398b83332bbcbfc88356dbb2fb8b9f3c8472b1bdd0b4134ffa375f846", - "9eab03689265057ae1ec1e24a9964978489780e73ec67740a1cc5d46ef6b5a96", - "ec031faec092367ee33462c454d9e9023bbcc9302f24350db62d25f595410837", - "c7c2ae9253a810b7cf2da14510277e19dd25a8212b6338c2de70f4a341a67d44", - "abf26f84807c495e22e3b74888558cb0dd9abf33ab5b4c0dd6654ac6c68f24e8", - "f2f3f5f28793dfbcf2bd39963a901816aca2df9032cc048414021e4c4a9ba956", - "1f4f94b054a9e28a7d6737a49171e23d3c8508dd4ab81af950bce7042c63d650", - "10b2d89b2641c929e24b66623cb60970a07ed3730e20d62f15bfa103620d1d6b", - "02c6e2faa01ef52ea977b2b39cfeb314164ea1a12fb0e3b8f413939552baf97f", - "b8d09f6d8a7bbf9bd0471c125ad7c0b7cef603598c6bdf4daa7bc767bcffc53d", - "cf35ac5524851dbbad8c26dab40b1d350048fa5d723d74e119cf4c5f42a01718", - "e5ea33cd59e051c1ffe43ce61895f78db6dc25a5744038e5f4df39d2fd1e244e", - "68d7bc9a31030a8291685c6dd12e774fc9923ad4614cd1f5b3c6ca1ca838008c", - "8ad68c834c7446f2a3cdf55f1567d3f090b91bdf2c87319d3fe8f070c3a57af4", - "c193c17a1bf6b4900c5da3fb36aa0e6cc08e238f0b8e5e6c21f8ab40803968c3", - "03790ee7ba443362a42b7a28bd4c61d6501a4aabc6a6c1ff3b62034011c2d978", - "d7515f870460e61c956a18db6c4db8b5cb6fe0d95fb267fe5f3d06a02480e24c", - "954f2d04195129f064a4be3b78ce079453f6bd5f0497bfb6f9a7c43a9adc38eb", - "42308ea999b0373b2f7dc1eebb8fcab2f2f75cc158395550aa8cbde321264f7f", - "a64beab31d31e11f196ac34b9aebe274cd362f2c7879b9f273e3a11b51d7566c", - "58996bfee2f56c2a813a037e3b59041848cadeeb9a92c4c0cb7dc0add57aa8bf", - "4d9302e687bf212c6f30305e4d92b82d0814c44013062adc16a9fdd4f3e21cc6", - "af257bec2b2c78ebc75babdff99f75d1d9df89ab7e5f530fd0542c82fd7f773e", - "1676eb19909b55814b4921f51350c465c3dbe46eab4e19420e7d82a5644b402b", - "4e0cfe7e16a1360583f04c210d9f78b61b146461fd62e6c4122cf3f866dcd955", - "2f9aaa76411b1ba45d38f01192a88d7c600f122c7d716745eab0091190c70436", - "d5cc67ad12d6fc3c8138cf3a5eaab7aed7566f6e71392f9ab10f8bd56d202579", - "b60d1bcf81fbf56adced62be5f5a805d675f3329ee36f9a7a1693265844ab415", - "80988eeb0bccea171d7dff2ebd2a172d727a26e62d10e30438f30781bbe03719", - "dad61920747e00b28308133b7f6bc123887a1f97c0961ba4c5a50ce0334647ae", - "8ba7a36a601cd57c1c149aa0958cceed930a5bdf05c127a7f8249bf16a274f4e", - "fca5b527842bead62042d45f0559320b69472162e63dae8b8b13f70dda189adc", - "1acf315812ba9fc21a58086ad247b0a89fa66d14e8562d5d8254151d905b178d", - "535448b85e0cde6e5e81d732b2663268a1f6bb5c757346bbc818af56051affff", - "03632641c59b3eb66ded213569af9270c222056a18d9f2f1e7fbb3e5ef3c0af9", - "e75308bc0d14f7462a04e08377411ee8e3f317464b08d40544b026ea5e82ed64", - "44303978f78ec183a7e06f28954b978fcad06ffea991e8dc8be59d9c70582198", - "038905a6ea1484fc50ec30e8c586d74d2529c8dd1c9f335d3f93e724de6bfbbb", - "ee1c89c1daba52bd96e95d69832e7f91e347fb5f34f34a42c5cb8d6363ca83b1", - "a26ad7362ba577c603c8f2a9a37dacbece7c85a0bf57ef6781fd47e35186c1f8", - "99de944f1fd86cc5f03b849ba680133f07d054e40b2fd249a3c4013d10d76aeb", - "7ea01880def2ef9cecf60c4ac0283abd9abed611e13ad7094a60996b97f26212", - "26e40f6dad42132968f512aadcb1effbc948c4b994ba21fab75965ba8c4c0570", - "97b4dbb5d66a95af6db43b70fb3050fb03bf71d3aa5d21472000229cc9068beb", - "01b760cc47a2e6bf8b00b3265b2c442fbed6c83a219c6f60e58bec8343948663", - "cf784e360a349cab5246fda54f3cbd11b7d0049698a62156872b9fe9459d495e", - "6edee969b6bac2ac384463de11ad1cb0d343566b0dda7afb518f6eb92553e3bf", - "1f38cdc076c5fa9a18d6fbb2f2c733f8a5ba8d762f408b3744233cd3aced9075", - "20f6bde0e0435dc6f15365269894fc087424c2743dcb1e9a3d65ad4dc46c9115", - "ce7d3aa8ed045b18bfc5729bdcf670cab6109f76462d7afe88f8a970e61f93c9", - "204ede6bb52dcfba9c22730c050af96add70fd48c3e3010263f3f6a20a28f0bc", - "48cc7fb1dc4649daa30efba9e682090724177e9f9549bb764c5514337f3d268d", - "24314566ae35a12ea52f0ecb4695f59845f253de083ff711497b9b101b6c1215", - "e9a66eedcda29591abba585beb911a440a6d6a21ddc2e5e234a3a0356f058e12", - "a0cfc9950b3b61dec410ce7eedcc16b491172ee194668ac41191922d34113bb1", - "71ec747aef87b025a002b5f3b2c3760ee7f5076035f19d9edabaa45d1d19cfd1", - "79f1e6e368e7eec4a5e829a5689beac2eafb630019af1001451817201b608f91", - "a8965e1bc1aca9dced34dfe1bd6a088f1dc5d81d7c7ffc97f2b32cc80fb561ed", - "964e3df98462f4a103c60ad5bcec8686f7d699755ccbedc1de9a9f64cca8c703", - "889fac97c5e74bdf83e7baef14e2aef819492ed87d69309fe8fc97bdba627240", - "39c3ea184d22faf658feb1ca734d351eb5b63a735ac7908a90e6c67ae663bae2", - "86fb8ba122b171cd6a1b629060ae71a575a7d9e336e989687567358207843b53", - "80108b8ae87ee47429c7aff77f4b4f3b14fdd9f692e49446edfcce9d4dd8654d", - "d95e671ebbf1e638e287049dcf877c502f9208ef24dc1490f78bf76a9075c3a8", - "9ffc2350d1f592ffd1b178a78fb5f921e1fef20fcca76d3b670ceeca5681323b", - "fe9a5fb81d00aec7b584318c9b73889ed5c7542a2784d2e8aa6f3d5bee240e16", - "08d54812762ef2762698ef50550a6e56d4917dd016dec078048c807a84604e06", - "992bd5c2017460cf61fdec3e7df2f0fe97d802f781d8c358893733249ee14c26", - "9e8a62eee855758e38e380ddf272549ad8e1161a535c5aae218a52223262c256", - "216197fd43f6b7ab6064d6f45880e311fa8a312110bd571f9efc0a86b61d4d9e", - "ef6f55f64c5e640a9def6fb02cfe63306adf3828fcbdeb0a3dda02722026a5b1", - "7a3d97a8d1175c19d40c178e73e6076a3a1163225ab6edf492425ab0fc9316b8", - "5d34916813e3654e7141b1018743ff6c407992a3bc04ca18f3bfd4ea10c109ab", - "c28aaa39bd0268c0323bf931f4309db93e89297bdf699785fa8a9a89f535d7cc", - "b754cfb5e1201c17b43b905adb7139a234d721a33a78b41e3b1e272799f90d75", - "7ba63dd5539547d7e6eb10ae6017a6790bea0c637aa676b5f36df0e33c79fe6a", - "3af2b6e228526d07da5370243c6d2cdd19cae0d2808bb70dfebcfc8ece1c11b1", - "fc3271006ce71738cdeb62420df2ce021e86fcb1a0d62610bd23c042d6442f54", - "d203895ca7309b7cef211cb3ea3c74e058a622c6f998153421bc72739180a614", - "2e8a5c6580bfd1e42e3e4adb3ce21db385e00d8b1562b5498e4f2faf12a27961", - "ddf61053d9cbef7b2466fc4a279d6d1a158ff6929baa78582e46ae890d2f7bdb", - "dc13b1c067ad337ad6a9b6be93d683e73de69552d785ee4df090c70f6e434d8a", - "5b51b095ac2832f85c71fb744a39bf010af7bc144eeeeffac8f22f2f8c0e6d46", - "96b4e6a65122131102e7af6ac9a9566e9aa6a62e826b7a0116ad13216360c4df", - "7b28da39fdb19a58cdc06f88ee5544291f34da7c05fa0373498c7ffe20785a90", - "ee77c0717163ff975feab287f1daa0f4fa11bd12e1599de564ad4efbce17d234", - "bbc2102bf69702527b579e70a29c4778ef98db82d36cd77b38026bce8fbcce76", - "84e71144856fbf9146e7bad4256af5ccfdd01b598e43602972d1a660636b6f19", - "b4b4bd135a8b1a6020ba4aa8d94f71fc7a6ecb54711472e2314d79e9da96e573", - "972da6063cf391e4059972722ea3ee8095e414a8425bbd67fc5b8c5616ab3a92", - "61694fc764c8c7151f1d4c1cded4b00b45174ab29d0133954ebfd2297d98062b", - "6c8b4cec9879f67354298dbcbd1f2ea241681b805e298c472eecf817becc434f", - "0f2495f4971b5e924b300cb323317c1e318a03fc929d8b72a851d578c685e0bd", - "43cca3af843614e81b82cb534996a3380f56504e5847eb094d18769070fe0f29", - "f65283a9351d86b9008258bd61c6fa5b880f17c44430431dac03464ba4c2afff", - "ca06647bac4db9f6528a06761a7a2df5506a13986dca57c82c863427ce913640", - "36c867b2bf979d6778d5fb1e3087187da3f779f30a4dffdaf5c83e45b367df2b", - "4ab8b85120fc63bc521610d8312e5938bd402991f9d8f2e02f31b2c4d9da02ec", - "b67f53f1d15f99ff678696696923bb3dbcd66c84e82517f29a472d87935cc6aa", - "e42cbed0b024bdf26163db927dc8dce3f14c7316fd8f9cc0735c6fac6158e159", - "c85998262cc9690de9e4a7ffdc02612754988b488b2d3dce567dddb50a871043", - "00ad01e897116d2710ef9b69b78e7ab6babd26099de7e577900c42444ad66c0f", - "919d76336a98e96b704f4ec6c6a9f1aca9572158c976745b441a7bf4d3423928", - "bc46a84cb43f62478eb4ac3368b75a03a2274b2a03cd5743ce57fe4a959a9b2b", - "e4ced3036e02955c70fdc96566612de32f186be3206eeb1d9e3f97c8b340e1c3", - "0225840b83a061c2cce9dc9a3e9ef1ab1783d6e17e35d16999b06d0581639b31", - "ff1731ff6e964f3dc825b4b481063f4e7b7f4b2fbfd610e0a1a2228f0f5462bc", - "437be65502bda13abaf097dabbb5bacf0c48b5eb5f6460826caa3d1fd151d4b4", - "f752ee191eda425a597146a9186e9e375a7f55954eb434584dbe9074596e68bf", - "c4f3289a87c8da46b1569b8d0db93fab22d291cf8e6554d8d3aedde3cf5c1b59", - "a62547d10fb315c16caa0e2ba161171e5c37ebc5b072dd15309802a42c380397", - "30a306ead3d6edf311d2663098c20e5ccce0930f675578303086a16a402c434c", - "f482e2a71373567d37219592d4d06c7c5873f87c68539789c8652c2bd3c1334c", - "3471503deb7e83c286d8657d60454fb454edf311892ad248ccd946c8916c7ad8", - "338b93bd07f1d5bd0a1d4f5a616f2b39f3180b579497627a795aeb8bb08442ac", - "78f40b89cc831cd79155817d84271402a3ef5baa5f66d12ef5463321e8ce029e", - "41ce0c279baa543b47ae843eb21e72c7941cfc8f664d52c326f44a3d14c37947", - "4b594c50d94c9077162b26be89cd3938748f829e2add92c6ee5056c983cc1c2f", - "bb7db4f40b3aead0dde2a121bc6f7d1e2bb509bb3f2c20bc5089bdafc60a6d05", - "58325eda8c556ce845612911a9af97bc85088024036620f7053ec1e333595e45", - "292f5d470397dc136a8cf40036373d230b1a92de2fdd4a7ac906a49c48192e94", - "00e1c59a3effae424bd7775298a7b269e88c0521a1812d4b014dc9deb8cc6cbe", - "77917cc5acbae3b0f0daca3204482db056a707e0c063b6585a2e40041d7bfa2f", - "8f8a4cebe1707036723cc95597724250d4ec2a2b59d29040279cd83d1349aeba", - "fa692ba04929b6c0f776f306e63de0ce68eb3e54588d506e4026178b6685acb3", - "2a408a1a48011f152279dbd8d7ebf38683421f25201e74f817daf46cea6c85f8", - "61e4c2f4b6d86c944cf1c4e74b632e8dc9a6f412f96ba5a737bc0b7e769ed953", - "8cb788e183475185143e58fc3441801365652fe21c9d3506bd00aba3e5978435", - "0ff4290a34b414bc1e8acd98b9e8e33d75965373101d645c1df679b003e58c27", - "be8f765a39c253f9f9f5154e6d20024135d3a34e2e52497ebfed5fa7aaa83fb7", - "ddf5f72be199f590376f6eed7e53cd404b29acc61cf8602a031cf691bcce1006", - "ba0f900b25a28b8ca348e3541cc33ecd915db2e71ef1dec94dfc31fa2527ac18", - "32619d47f63a7a7fc5e58d7ad19a1035109fb69350f9de3d4f99f4870cb01f32", - "3cf13fb90b180bffcbd941534ea218663dcf896f7d1a0c2e3b26d7e113c68871", - "7a4ff30a89b6418b21e9cafa8487ab573e8c48c9e7d5c4f1738af86bc273643c", - "b6a73f24d866226b17b366b639b20a899291b233f6642aedc1525d19c889cbbe", - "33a8c2b78a3b6f328b982c533152d717f06df69ef2660f70a1f9bade4bd43edf", - "644f29cedf137a611e8be0bc0ab5c9bbff0b930cdef51687ec8ec22a7601af60", - "5d952f903fd2f07c3265b8172a6120972bba802072e1a94e7821c5e51c73d668", - "478eade967d7f5140ea0220f527234cac271fc5d17eaeea539274b9921b5e93e", - "705a5326ef7f711b0f34b754030313a18166a8c6651ca6b0592037debe52a987", - "85bd3f8b6ff2887f8341e61dafea936c6bc0bb3c8a73b429f0b9cef4cd7c183d", - "d83c81c5f1891ecb628b41d32609def8f449cca6a315a03310d03a7242ac13b3", - "d70f07dcc67de0b1101e02b134f7c60004ddf5b791163e7acf9fc2ffed5d64e2", - "d4906d0816933587c631b9aa3316c3d11e4838b6faa612d89419fe4fcfe13d76", - "c9e7822cedca145ab84c6d1b9da7ff83b2044ae86980d971e22973acc54c81d6", - "44edb7a7eb6b1b7091cd5fac20c20e75007edfb7b1a7e99ec268a5b7eeaf7298", - "d1b691af392da90ff4082e39deb331775cb21ab5b06057bda512799c94d1fef6", - "67ef291395afeacc775aeec376f7506fa20448529e4a39b1414f45574541cf96", - "c1b63ef79dc5fdc242a3f83c829d516bb6aee879c75dbedd4df2256944697bc1", - "588d118f24f674ca80e6b82bf2a78d2668dec1a8e072862d94d3fc1bb4e09ef3", - "6289bd037355e99f0025b080836515337b4071987a07f3b82fc10bf45b940086", - "41b50f34f7daaf8d5e52b61326b0235c324f75bdef21adc519c4f8e7b9e5fd78", - "13cc6cd354c781e4b6816cc3637d36325df6e0b4f02d5830509506a6df6c1e17", - "96ba6371ff083991f30fffe1329461863386e88e43eeff88d8e71ba65239a73e", - "5169d687b044fd6352ca1efe4a5bc4ffc65ff3e70e4eb8750370c7c29779d128", - "0c765170e83488a330d8c2b3a9fd384ed987287e42430760ab763568433c9790", - "a9de5bdce6361a7f3f87666433ad1e99512546423b539825561ba65d59ad05f5", - "6a0ed819ce56565bbf2a38c37a088219a4145aa9bcc8697ef67472c2e338b54e", - "ac6349e9f576d09ea619e66dcc932ae27c9686102847383606096d203eb990a9", - "3e957484dec062fba067d2c8b7e0d3d0bacd2a0cd11f99f259a104629457dd5b", - "7921118ecc24c2b789723c33f0c6fbdea0465d6be425a884aa12d36ce7ba774f", - "a21f4eeaa56b11e021b5fa616c163309fce86b867ab48f889b7bcb6ed3774cca", - "aec7adfecdd5875bad3070c15e9d64ba4a0d352c5b6f237d471443cf05ee1f73", - "d31b9dd7b49679cb06f50e46dd2b09ecc285a0b873b718967f5f8663c4199b6a", - "5364ad78a375f913c67d4ac9f9aae4ae5e04c84203bae7186dd504d87da384ec", - "fc3ec63c99c2a339085b19a54d4710d450d88b4c02635bc9a95b961869d8cac4", - "00aa76e274a59eae168e6af75d318d1c7fd44e83e9de070027aa396d1d2bc3c7", - "bdb6c5363d0c58bbed272f6569b2d0f5cf1fa770d7dd15890daff792f95eb301", - "6059b47411b7ee478d14425ad6a2166a03c84841bcf7e50ea4c000a23ac8ea4d", - "6bdf196d88d7851f7fe2f84dd1425356a5d6ddf6a9aa9d2c2c0341dec515e21c", - "7de7d5ac24abf2f10e9506d4da15b719121ba8f42a05e238b73ebb05519ee939", - "ef9fc88471c1d4ee83ed0a5e8923d162ff8799f233fd22cf1574c454ece618e1", - "f02bbdd76dd38a60f370ee44d65cb591a3c5ed420a37801b063214aa6ab45c67", - "32f714e7531786b79fc069d405407015f4b3a56fd7be30d16248090d5b02f61b", - "2b7332e02c0a863b1e4388f5696b8cec3ec2700bbf5e2ec7e85479ffef951e0c", - "e197287a8fc6657864c91f73848e01210549979acc88195994f8f5a302e86f50", - "32b2b126b933cbbc52029ee673d2df0298171542338b178fef7c44a78583ca92", - "97de00d15ef9f5187220b4ec3920f038d155ca031256d6dd96dfe58fa40feb83", - "fdb7ea55faf78c7d9ba823ae9b7e0cc3269b1c991b6bc64ad162597a54b6ef4a", - "3c6b6a7c126e541e3e413947dba6b4b9c699851013e1f532e46ba3041b4a8e33", - "67845a9dc4fea55563a6b350c698aca25e0d69af9166ab366911f5388946728e", - "c4e1cff5585ef9725715e3c263b2cfb136608e063438cc56fdfafd39ac1576ae", - "c8aa6a303db8f36d2532da5f79fc7296c5979b621e8e9c12ce82328161ff4970", - "d98e48017bab23678b2e3a9d7cc9a79092c46d306eccf3dd35c2e23a9f12228a", - "d29fa7d886401c159775099d2d1a978dd3b659f68a19d721185cdaf41add495c", - "386322d85f291a61be80b324bc148a116df1b56fc3851797c651da5a52a1291e", - "dc89110a8a617974f17ad2169cac56341c36efe90a63aee5cf8ab26d144a835e", - "ac65636fe612216847c51db440f51f41c23e60b68acf385c2bf0fed9839e8735", - "31bda7760afe9531ee206714e1e1970fdd781035666f765ce406bf740306a6a0", - "5a4bcd584c8fb1fc2760450b4045ea8415f68a210b92524645629265abb1ae61", - "e728cf5b42f9100da47cfc7c7195e5bc8b28b270f90489462cd98c2be1e7442e", - "89d67ae66f715e2c630abcd99820f48bbd5f913c1faa21057828be3002a7c0a8", - "3e607729f233c3350bd067c65686845eb4f7e9eb8631d38a32c52e8040ac4487", - "746eb674b82dd3bb87c27898d41cac90e1ff00e1d34f8e00491f71b54ef1f9d7", - "00db4c5f51cf271a75f1f8b3ffd1ff68bc938be66b69122c4161a552f061ba4b", - "7cd25cb4945f6ff27d8953577fefc6b7dc8081f573f044bddce711976e5559d4", - "701f77dd3fb4c93d96461706fead0a624a9056178e26131c30a63ad7fac87fe0", - "a51f764e96bd2e24dd6b40163cbf997432a83b3154ca12be520a3858f594afba", - "4634838ae13b5016d8e82312f81c176bb7e05bf4ca6e296515136ca75590b61b", - "4484693797fa70c31cd7e36a28603a64da7a6a5164dd0cd429a0acaaff6aa0a8", - "88a17575db3729fccc653fe071e402ec138cbca77329e46bd29f556740c7a65e", - "5defacc51938ce563be69c9e3f73f52ba215d3d02f4ebd7bef5fe2bf5fcc4b59", - "6ceb76a3382542720e2d433c8dde26049c61566da14d831ef90cd235e5425035", - "1bf72bf5f727e14f1b8df46bdf7e1fc91746550dafa8e69b7a583e1fb3709cfb", - "97661a41f4ca7358afd096b13be94f556c89fb8dbc331882c39faec16f4d98fa", - "14974c2560655ad6d07cd3d9d43796fc0816dde7aef59a6e72ff7a6c3e7ecbe8", - "fc3ffdce791df7dbe2a636efd9a766266bf54078484d55db89935a6af49b1720", - "0b6af074da929e2cb8b3e4383b2a7680477b629438869b7d9554e46f10e59fd6", - "931bf1a25024c8c4dad2874fe33cb16e03c65d95f0fe175cdc76c38a859b155d", - "0d518a0db8ba67e7adc5ec54fa1ed7b185db56aeaff037110d9ddc42bb217a95", - "72c04391088cb05181ee75d95e3de771d277a1d7c686cdfa4b5dfeb394bd7b37", - "a11dffddade545dba05ee6c276a39383b4eb1d0f99ae3d25ace370e7d147e55c", - "d948377a761a93ac07f28444740c23e8dbad3d9b515fe457a7e814b12a37e7bd", - "cd3154c3f23e9e44b808041e5b61582f24437a9260795e7521b3d46e6cd5a026", - "59508c81afbcf43a7d0f185214d3f8ce9ced7224496496213a540cbaeba63967", - "33d4016b7ce611912aace248265129a0715bc1541c5902edbd8cae48bfe0c771", - "6c35102179fb8b5b5ca28cf269a3067f09b60f9aa0b46f8a9ddff3b6bd972321", - "2b3827dcff90884255f2f01d6ef93f8e7b7dbd4cef15ae0670a704a49e6c42d4", - "6639377df843a5d9e409078ce930a5a2b53ef618664dda32497df280dcc26983", - "f9b0f3996bf9b476867af700546fcffb0cefeca6706d227061d14aaacababff2", - "4a9dafea5d5610ee5f7a31a16e7d6bd24d801d8736ad4a62dcc3885e050a68ec", - "05b29a5256f8981525976a2817f1346668f7809b7cc94df464c0e2fa9578fd3f", - "113310e22eccad4b65bdea25aef364650620822f8d3c9847d98852c148aceffe", - "7bddd389adfa9076467e72e7ebd3ceb5c4fba02d86731a075cfaf7fe6c319a85", - "372d1e685890ed828ad780296bf4718860e397e675492316d3be155c7dccad7a", - "19d8939e084dd30bf639548129b8e93193e5d067a323b05f12f4c8f67f99200a", - "b031c9e4ee641424d908c2b60bafe9c77ed0a2de93d9be04a8ee2059d9b1b991", - "1d933afc2f0fad27f422a7c2c8619e87ce5f5a9957474c9b71783744ef04d2e6", - "97c4dd4944bbdd35c81592bfd21802747657e8ef30c7cb5fd30071990812ad0b", - "dd695ec34872ca9caf52a07dd9f48257542edacbb142b1df352494e4a66b07af", - "50eef73b99a7e81a7471cb2cf5387a54188dcb6775f2cfc2ac84c136664006c3", - "61979bc8f71a5fb7e0af0e5cd82ea408dcdc2364b427addce710460c9ee86256", - "b798c5c6773cff8c9d5e78197679d175ee925b3281e6d9766efe9d33e6d6b5fd", - "3a3ec3594447ff7824aa9db9a188335f8906e1e71ebf0acf89c1923171b23d6a", - "51e1d4b627ef1f44edd5fd28d447af8fe3731db133e801fb107c9131df54c028", - "910c710733c80410b26cf3a60fd03a8f7310ccc51976d14d1015aef03986f8be", - "21e979b12797de35572659cb4ab34bb5896b0da868819af0e10e3c1ea57deee7", - "0926dc1d5e881455df1f004e135850ef3ae28c7589c7bfb3021d9a51c7f5f450", - "7b5300e43a3b37976ddf7381b35b810f9909458d660b012ff6bcd4adf98e7481", - "6d62bafa13bbbb06077a68bb65a32f4aa02324904fbcb18f273d8cbbded3bab9", - "dd6bc474fa6a5b3aaf9b5a1918c949f8eaa359049720acc32bd36ddcb8434f80", - "a082f9086d9991006640f5d2ce89e3b328af455b27467dccfe5705a630c49651", - "15d1db9bf2750261e6c76ede86618320bc1dad03a89a74b66c3b3002572baa8b", - "cd91ebdfd27483ca282bf7a58ba71b62d0efdc7b78a017cb22199d094a9bb068", - "326257b9d1d2334339982904795ba199b4d3675cfedb5145025df2ec2ca81cd5", - "e6beb89732d9f5e0d42e587febabcb3bb1f2c90431f4623ef68f6ccbf47560ba", - "0b56506bd5f73ffada0de2fd3c02fc3d6ff4cb17b62e2b7971f111b54acca64c", - "65f95456c6d72a82587b9829233bbe989c5c71913c2a6989b322b100256a29e7", - "6931b5be42d4f04944e531c261c8d6e42c4df17dd8bf7146a6e2dc691fd98863", - "3bb2618647aee2e74fd8a15a91cfd9738b96118dcba75f3b12f2ef8c9db2f50f", - "727510034d676addeadc9bb5061927d45294992f8e7b629577f56d51bb3416d6", - "201a40620b7adcf7dbeffc5db5dbfdd759e81d377b8c61cba80f51c92e31750c", - "0ca50dcf1d44a878c50c34d5ad688c8a68b349709adffb23f3f8da2876e7fb3d", - "29b8583da0383a80b1e3c5f523bf67f34253813d6fb828fb18a0ccf850f7ca7c", - "9247f04ebf11e1490424e5a210ab633771cde4a64f3ec537b63954817d1ebc5f", - "af3592b5a85e35238a6c37c71c55dc2236f189cfa1a2e62f1fe42e7410e92d9f", - "cade9327aa50aa1608f8a082dde69ae0561f4f80aa4c59974b0090143b75a024", - "9fcb07ed9685f1fce5bcdc494e5434a4fbda08cec511f696e810451987370f1e", - "115c487218231f67356f9421355c9de86676b3b46c68f618e94e36ac11dfa5c6", - "d7bdd6a7656b35629fcc776a9f2ddb72b1f125d18588436e24e4760a65a75ecb", - "fbf26fd70c5da9ca7adfbe32c87b5558dbdc38fbb9ba233e6338ea15573d926e", - "dde95ae5b434b498b4fc2ac11105fd7e2c36738c14b892ee312f483cebdc5bff", - "02b25529ce22a2dc54dca6dca06996ef594f9488b3a3fe3f2efa4da7123e51f2", - "b7c276e6fe06a5185af8b922ad00abcbe5202bcf27bc00f01382292db14a2760", - "48d980debc3257909801c87544bbc77c1cddf6fbbd2bdf0d5c8b9e4c7da5a76b", - "1ad17e5bb20a473587ffc06ee63065d091d0771ea00a6832988090694f47d019", - "b6d79da2aa3601e38bb2950418156163580516144cfc66c84409c86d9a4f4026", - "d328777f7982329939a72de6ca5b19219721548f9d6e8b785915f0e751cf1612", - "6509234995aa4e64f6520900b3d9749734a1d6efd88081db2a94be8b6d099fec", - "7b5333f04d92af6524bd83df041f611ba6832377d78414775f000299e165dbe5", - "98b88f4d61073d76724867a5b85484ac6c892a43963c680bad974f3608dddcd6", - "96c77893492ae2a0a1ab2bb683de5e5107ae340cae9977788010d68a58641970", - "a65b18de058364864cedc6bdb1d831063bb15220e06fe5226fd7e8cb4b4c5af4", - "58a468e04021b6ee78c3a8207e6607ce7dcb587887cb192631c9736a0de9cd54", - "cdf7993f170dff91a4ceef3f9b8cd7506e047b7111daf72a852300fa0fcbecd0", - "68f508f211b529714a6b789843501eac1f0bc6fb4be621dff62ec2f47152666d", - "641b400a277c97caa9318a098c5f0ab719c34510457a0c5e16f379856e03c9d3", - "be6a5ff7f5d0c40b27e9098f52a5e006a5b940a7a96e101c2d66efacaedd2b02", - "8278881104b7309b292145a74179114bb3e7ea8e6f5e20eede9c7bc0a6bb5b35", - "b6713317db1466d0af61ee915fbfd5264eafb75bd4a2cfefd58e1033847935bd", - "40b2a7205dc29ddb4020eda5f797806ff40cac31becab0651290e9fc2e3ee8a5", - "ad5120992ffcb58bb5a1b4ae48ddcbd703adf807e1665614d2f4206489402101", - "fcf8da61cc16c772c6a502766ba944e86996e5e9a8745be63961e2f02a6f7875", - "17cf8865e56aa2f21899a202c54382f2e9d188e0b834b52f46bd6c931449faaf", - "00d23ad8d9385ec9a76c996fd3fe3e7e8c8d56af13053c8555c97a06de152811", - "87a605f0f7c2150db027980cd51fc9ae280b3687ad421c2384aa92cf52efafbf", - "abc78be33ea777bb6116b6a37471400c653d0411681e77137e01a229c45517d6", - "9464239824271f00898b1055e22dbc96db6c2f7b4cf81afc6a12d69314d6e789", - "f49e8b7344c475245fe0f1e8f490a385495f99b20d68316438a9d11a0f67e4d3", - "9af6deae7e8176a2b3505814d74435c89f0b18387f558e92dc5a0d2e476a64cf", - "ba2e31d9f08cde780c9eccd2d473c67712e809287d44b07056e49ffc3e002fc2", - "bd259e73ec8425facffd104ae7e2191037d3266b433bcaecadcba2775cbb22d6", - "d4aab24985965ae5480ba9c600f8ab6c90ff43926ef7d37c7c2cd2a8a26ae48e", - "64444e6d733e6b4c11b167ed0c09aa7fb0eee9eab39a7131c2e23a94f5d84470", - "b2d79828c057a9a745d21315f0d08caed448da897255d830600348bacfba2773", - "b43b35c62b4a2762c621e1b1d6c5d9f0f78a78f41cea7dfbc2d7d8642c2cefa9", - "8b7a3daeb5f7bbf50cee92bb3b89d8fbe2a96cecfd73295ffc647dde51dace00", - "6c775e88d021ca4c90768c953fbd6b70c739b1949340fcc7f1515987848c79f3", - "382a5ba42fd309fd3b0191b4e3fea180d0e062d328e1b051488adbac6c507de7", - "edfb1a2b6ebe1b1e57a6bf1ccb10718ecc9b8d8acb01f1c10883b392d1dc4fe9", - "9ab858063a705984fb3797b9b6b56eb2607947a49ee79abc757db52d6104374f", - "2df02c57d8c8b194683a7803aee51c6d8bfbb93e0f2c03a0fa2377262191d807", - "c9104b8fcb11e79e6989ecf8b48bada0f5d80a666d07c1c18b9a974f63661933", - "7d2a0382b0b7b54f9e84070c52a977495b60fe481a900509ca924b76a2a74751", - "d08d3a478160b41983d572d331e39657d12f6e25f985d3917b18f3c58c741827", - "2c84c71b2c62e3bb26d10e400fd13c93a5db58184a8d56326564e1ab67717757", - "987dfada4cc58431d5542cd9f7e26b41967925b88993be8b938ef2cc66a54e3e", - "29520b5ffc6986fe73b1133a348979a9ecc14a84a25dd3fee1aba2b4e89a86d7", - "a254cd7fa680a49d87a45b1ea1379d0f41c47745240860242e9954bd64daed37", - "592fdcba0f9f8354d5279d20412e99927b281ab2936b21b1cb3fb024dc23d14d", - "7649e07b931f01d15c94f74851a4ad555b92f87a6e88fa841d8fc523bba5d553", - "49132b008f571e3251f75cfa4d951325b199c830f236714c27d3281d50557986", - "ccc6a79ca7da8744920b7e0664a01e8e46d43a90e3af181be14dc151ae437916", - "4e190f836b2bfb76e737c3c095d021fc0596b1438528d9801678ac80710fc641", - "0ecae9df37705c241f23509e80d1e5a846233ec1e032e40f0f03d2ddd3312ad2", - "f46b9f871709afef936a9fe4b02fb15d9b76c7be593411174d249367bb59dcb0", - "35bc02f03ba6764260b2ed73279e95266b6e9df8bf7b07e10f801a5884f8db95", - "b3d85469daf06f73daba9cc9d0ece7d8ac22640182fb596a9f41b8952682eeb2", - "95f9ef70e94db4c2aad34b293ea8db02da3f68635b4195c8366768fa00446263", - "645e97ad1af9be733a9d4c9d4b8cb3dc59769924dad95c3c761089d5a422bfa3", - "39f58de5847031e359de70ae2c6098cc2183361dfa36d0eaf7a1373ff3191bc1", - "5d09eaf0df0c6b02b51558409cdd6ba3b2308d9ea129b19163e54e181d83b912", - "88c0cd0afede5a51be526d580e1d3b1f1b24d6ece126e5374e9550ee9257ebee", - "f946dc724c6dec301cfe13850b2024d1968a6fed64867b043ef8d0a41a093c4d", - "e693b547ba5784e7d1d3e5043d1c8f5b08ab5ca09708cba66c64af4972a90ec1", - "97234996715b7705bb0172f3973fc81b3134b897cceeedb891e7708c59b6ae79", - "ef0f86ba242886c70d7c826b0d7b8a1714bf80dba658bc7ac53f069148b78a69", - "ce0817f9defb2786fc4a49d8761356c60701a373b602f962c02e467a5a968a30", - "c4980cbbc5ead8b58ee093e07857b1d3701f80e00858fa000de1179359915799", - "01231c829727e6d7b8d0a6cc3849a46288e8f3d4f512de0341f88259bb69e8c7", - "c5ae6f7533ebc57baf53babcfb85c6936a63be314c46c3bdabbb4678bed367ea", - "00e0b8ad7348f6e5b1a97c72c492ae2657d48a9371f5412b26f9f36318d5a5be", - "51ffce1db9c9629032a633d9dccf30cbb557825800e541c6da6787df4b41253f", - "5da2277cb2dccb7b5e661e4b617815ea3b84bb0e11529ef7c4c3f55350c258d6", - "8f53327f8c8329b3dfb66b9eb18a817babe9dbfaaa6c12f72f4b72b161072b0d", - "39a6b7ca518c1ad9531b12d35221cab4ec4ea0c057580328ff5656f2566a4d23", - "1cb748baab69aa5c5089917a124a94ae0d8e2f89be39e0a702b33bb81904d7f0", - "ccc38afd98eba8ee162aaaf48b24152269035dfabb128cfd8103d28338e80c8e", - "a9de9705ceb2003bf8bcd92276ca50385d71e39717be0a8bf29a4008f51cbe66", - "bd7fe6d5ab782758c9937fc376b9b42918f0a3f44abd36f8fbb2644d512c8e95", - "69eb741de886c87fe7fa391411005ae505936219a9a83086a6a82b0baddb2caf", - "c8b54408b6d0d746f6bdd8f09203049e977c8508314c2f37dca87de189bf7379", - "e8081c54408ae945774da9aeaf02b5b00a31ab998d07ed5ca18f93350bf91219", - "ca42c94db8260a50572a196af790b2262e575d55971f7cbd94e11fe4cd92a6c7", - "39033b3dc139c768d7fac479ff48a165b71518bd6e0915f618a40385deedd2b8", - "6d32fb89d592ab5042bc339784063c82bcbf7d74299a224eed557c3299549b5e", - "d2ad1e3c8cb03773228d6fcbe1050b8a0367b3c4c6c14f74e6caa47d86d7d592", - "8604268bae1e1b5cfd1581b068668463a0544491715ab36c38275e58529e5632", - "b157f6ab15658307b9b891107d729768dda40a1a483d3d010db367138de6bc8c", - "22b35e147ef9854c843fea90f6fbc9cb6aad4c70579c9bb968f9f560a276d5b4", - "c3199e5908c96284d0fa4de3a2d1d22bb3c99031441623f2b6c234630b6371b4", - "9520ca4396ee79d420882edee7eb081218d84e38359f31ae264ea615d3a03490", - "e4ef414fa5e704a5558dddf521b060961cd732de4f01248cac9ca4da733f97b8", - "69a967655e79d0d652af97494e8e83820883f194850ff360c1fb9405902b0812", - "9fb4912d4a8778a198533d84356727b268ba567cea2c3f247194e99dfd6305a2", - "d2dd7e1b6f2d4b15f99c0a93d0d4b336decab2676b5799ad227279104f343e72", - "4dc09053ed57b1a23ee6bc22e4f4fc519bd09da9489e5279969acbd30cef9475", - "070a666b8edc4d8066675691031759143bf4b16df3221da971ed598bc6ec2a38", - "9fc6ec4147deef3101a34292777bc4eb32446c970092878138baa578f0b42b04", - "359f65585f26bc545d55c2b100d15343ce8fb6265d57bdbcdb5035bee15ac01c", - "de7bce337b5d7e68ca2880496a44334b4fc69a29fdc78cc8e60828b017d2d41c", - "d9fe20d6116114f5904d1295ad83c13e4e375724f93f67022ca8d221e0ccff35", - "8faeb078b43b8eea8eb4e79e20ff9c2dc46c44261fbe8830bdb49ddb85cd0095", - "ebdd70222ee215b2d038e740e11ffd8b92b44e924255fd76c3d20a76e351f2c3", - "dd3a80778f1bc2e938e359d7b75bb458c9d7b08b48d2ef7071019c35d26b48a7", - "821fb1c787cc9380c3e49e6844a7ba623658c6c118ae20d0dec8a41057f827aa", - "a284d991862c79af3ff845ea5fe3846b7d916e323df36738c322ccc6994f2a9a", - "081f3178e929f87225f82603ee18cdf3bc4f797998be52bbefa425f7e918df94", - "f19da8a63327844e75259f041e33241d3fbaf331923f2388ba6e140c7adb6e23", - "7c87ae0eda14b396668853eeb8faf18d5f5e34fcac0dd226a3fa8db595f0bbe2", - "dc66cbf28fae7da3b1f0852b6bbd3a3206f054b0f859c2466315ee1f18a5ee74", - "93238f30950fa37821ee511599752be865c4c2a863b2d07409d4c46b5211d24b", - "2be52160719e8c716e118674d22f36e73f04c93a6370c10db07a40970836e679", - "561741738eac9957bab111fdc8797b0eb9eb3793e2186b2d9551f14c3d1cb143", - "3a7c8d0fbc4b1adceca6d400376e3823d6d5d7f54639dbc175b51ad1dd8e2142", - "1e323d063d4b7b5d1a21e4c404020b6e68056571ab7fdaf9d0736d2f31bfe208", - "689a9edacf4f3a471e77f5ccf43f8c1a5c08949b7a4b11935a413febbbb67bfe", - "8f3108af82515649452545cb5755118e36af8235b54fadede650ff9d9d63ac38", - "d85d3fe023b2cf046ad5f76224ff31dd9690b70b421ed718a715b4aea83b8b22", - "415016e869ceaf9de24e000aa1c5be93b51b5ac31738037c2c749067ca08cc40", - "0b26671279437f9f9a6052282abbe7c797100367b5c327f7a10a654993ccab24", - "fde1da32693754bbf4080a76e2defad78d88150770ea05837d361de657842af1", - "eeb045fc2907df58fe2041e332ac652944d9061ab1da93d170a7ef8eba0805a2", - "751a95fc355cf9d0cdf7755fb76ec59c6b92dbfca6d6b0833de248505d9a139f", - "dacce8604e2dd3808f77ffa2415464fd1d53e3bffe24f04a786d8b64cf60d680", - "db7a98f6908ea5c369916c962c2840e1faf7a65af0ade3a6db5b3782361b3f3c", - "aa1c4769b59332ef68b3dac3e34c434dd1aabd7ec9ebdb204533aac0cd00e684", - "7abe9483059804f77c72bd02aa3c0a8708c331b04d125b4f07b4d9dfd214865e", - "7803d89352953cb87a5b1aa875b5a32060ec93c853c28e81836b4d397c114c72", - "3e9a51edf58a1919eb551b6af185fce866d5cbfcbe757d46011ad5084f796f69", - "dbbfc04d99cc3591a749dbf8c193f6f33649e7e8f7939a0af19c9e2ab9e85c9c", - "209fc6b280527c8993735b338884bdcebc196fce1b4a61da7db0437a5d0033d9", - "6b574fedac24cef4926f1c69f1de3d215a1bb9cb2983c525d7611ecfe6bbe2c6", - "ff16c31a9fb8fc773946349fc32571dc54e30f39a4efb45fdf14f384513c4da8", - "1a864ed387fc3d052253b6bf173a3b1959768c7a5c34e105c3876da158d0ab75", - "3ffce337ef7a72bb7c3478ffc58bdef0b68d3e3e912e0e3ff21d3aac57487c64", - "e052f11529d4c6500fee8d5fd144de681629c8b30864014036bf50d6b0228ed2", - "b4d4dba49a365fd71e524f49dd4d8b345121d426da46c514199d674cfc0cc356", - "3bbbeeef5325aaeddccb210c8e62d7de092fba5aa4540b38942c5654b670ab69", - "3c4d5108792661f2937b269ceb4311e4a644f853bc452a2ad60a63803ab55e8d", - "38f6660176987a9a2d16d09b43ec473692667d5f8b8cc96d5814cbbd3215f3f6", - "a7dd58a48d1e2c7f70927e60d5f92176e6592d5fab26a1eeb0e963db18ebfdb6", - "eaae16718cde828d8469270401653e265590f233778b74591691f294104bcc31", - "4228f0fedcd27d58da126c5e97472c2a87633906de6f4c1d113b3a624f978b6c", - "1aefded0cc1a09631c7f434fc1f67cfb6cb7f52dcd995a715dda962681402443", - "513bdf1e477d9e1a84ead271e2568ee334c713085c5835e2ee83852db7621284", - "392ec9ea8418076987a81e6b9f272e8e7fb0fc471c82bd767f9fea934f1cae18", - "2ca35641b9adbbc1e2a08eae10dc0075bab928552526ee543518ed06e8e4408d", - "2136720d6689388591e83ade095d040c86381ebcaba62f582d57f5a7b5c0d06a", - "112ecd4b4b5046e42c2689f7fa76945487582b3ccaebc13c3ad0f142a382574d", - "6fc61b794adaee78eff82b1163cc06bc34bfbe8cf6eba76460c65a5025fd9d6c", - "2ef5b5ba7b5e0553909d8a3158d8e035ca3d13e429efc0777c05f617e4791cae", - "f4fcb08b2e900f3db0f1648f54bc95f3e9fa17b348856c0e5369adf714459142", - "ef0045662fdfc19d0a3f2e5311d5c869be9a3ba83328c0ad120900d59033cb15", - "cd574697e3298361cc53627e1c70224c22a900ee38ba145139fca600a0bf9881", - "2ecb11194c4b0d18b8d7a0c792f33702262017ac4a5fbd89951e8bb4ced84483", - "34e1ebc15ad170fabccbc38cf31ab41b8b5f270f9dec6219cb3c3cefc6257bd8", - "e7e84778ffb4d2c3fe2599fdf40e75264e5f281b45f47dd2efa84252e3ec38ad", - "e3a99567f562be9cb88e9385c21ed0c9bd69ab30d7050518da19a32546c68bfc", - "52e9a35b33c798f590d3a1fa9d4f2f551441b3c39550b5b7107781898b4fbdd2", - "c46dcfbb9c41d72ee33b6490d6902733b7b4f2e11c0415abe6dbb25a470a0533", - "71e08b4a89b74f14bda5c1885a3a16e052726fe3b4749d701fd278653579091a", - "44280e1626aa0f9892cc6a1fbe97a4935409c1622ef6c24a089e81057514af07", - "a38452ada34c862b989e25c847e96c5a893205ca31b800d359eb60ce36551283", - "adab350e90249a62f8b3fcef3994c9240eb7c8226c363b52ca5a4091c430d96e", - "1ab1da521aa7c18f5676c9195c4ac96b9b5c3be821450bb337d87a2a4ce65b15", - "5891e2af76fd427263a0517f1cd790cf710b7f74a7c4870abd1095d9c6418db9", - "90446486bab4ab6af8d0ebc16656a12d91f314e1701c891225926d1c92b7da55", - "134b7e5875db37422f9a02a7f9da135ce9089cff490ab6e12fa69ab509a60c4b", - "0bc38e1f4b5eb922bc5ee7800d4079fcbf8ecc404e586aead36bfc60418420c2", - "203c4cdbe30d00ef8d76fbaeb81077938252195eb0d73eb78ed942c2837b708e", - "dc87b9af6a01fb06a78034d1ba60f930ba730344c70145ce2a6f8ea10b909d81", - "38ddafd5bbd14ad15323b075dae7b3f20f72d5f722bb58925135377b77f2be01", - "889a8dbec852104b3a1004c418a599fe31fb24734c7c0c7e3658d8b231a81448", - "22a8498eb1de5f6ef32a8511a5bf46d54c95423426af92a9c31805fcb8f6e27e", - "911952b69b068864bb7ba0a3b6f8b9658724aecf4028880d5b1be875bcac69cc", - "84eac6b60112f7fb9b6bdf4b0ffd09fd7e7c91af7dcf25e7497de83b73299a49", - "879b71f981d86e1a1a8b931447daa523ba28075e9e254f728399df06f051cb2c", - "d0f102581a478395882d91830927dfb516e255d936048d8ad24d9eb5a2a10bad", - "25c9ca77290aafbb6d777c1726063000e8a934ae646b58e089d2a5348d96eb85", - "6aa8c5783f45894206d0fa72381b0080ba99cdc409bfe7f6e985eacb4cb455f1", - "4b96de128866e9bf7408fb38b0b64d2200aa28a0c46cfa3485da39ca819b385a", - "902bdb46838acd4b2fa5962b04871f0501f9af24142517a87d39aa1f0341b40e", - "adae1263b867b6bbd9d54dd7faf321780859f077887b27bef7f10fbdb051deb7", - "b33fd1a6d95d9dae75423523e3c038e254530915446cc7d4020960d2256ef04b", - "184edae0c461b9b5f13acc3c5d2151bca2705a7e2b2af09ae91dd4949acafe1c", - "ef3b676fd3f93dbcce81c98b34ed85281e7c5918fd27c71bd59079afb82b01ba", - "f916e385761230828bf8ea9586ad7f3f9b681b1a097c95fd4f6810e71d5af3a3", - "ea20b928adadaa90e990d05d2202d6659aa4af9bb4d668d81b25c054b72de725", - "35ed5513f3566c6f564405c820209861127e66cf0c3e9a69716e0ed0344d4b34", - "41f247d370e096d32d00891ec7795c469d5787915a3450364e986c98c3a35ac9", - "916eee31c9a6a3c3f7380487533e186926de172c347655403952265429cfbf7e", - "1800c25d85a42459fe1ca631777377acb8cfb70860cada9c1e0eedc55d446b6a", - "7b7b0a0e6a0da748247f01b404afe04382945b0fc93bd19920bfac0a86adb9bb", - "ef8e40ce92cbc5731b543aeab53a72c53d8f99b8ec4e37617a090e46bdf39120", - "50a1939e6bf2ce73de6d828833034b1616f46f0b87d872285b16599dfe910671", - "354f2435fae0fc28ffdc0f9d70257bf5bf839addafd1cb7dd561125ae83ac0da", - "a3b70da8735d404379871affd4af08c5e3c458679c1934b2acd52adf8917fd0c", - "e4bf9c4a2d4be9dba6afea03d96996d2a7595343ce1d361a195dfb6a099e066c", - "01e60bbdf74cac81a4df65d56602bf0a5c18eacb310b025463bf95fd71a74c77", - "edf8b5799981d7067ec55c818ac480c5a6285bc6460845991b6678b135fbd84e", - "fd96c93a173087d3cd0f9089064814e915083558ab328c7878dc7ed48b4b058d", - "c69db2be164f8dc206a7af93e02f9c69cadb7a93e3d7e366ccbe56c7d6b8cc38", - "38b296a208347a2af8397ea099e2e195fd2462ceaa4203ac346f1363b2d3dd12", - "3975bf8065007bbca007c3eff4e22bc1e70dd6efa076b26c869e4ab80c3f20b6", - "372f65a9ba156189c0cac0b560619b6f19c08ff509983a03740fa0ca937ed7a2", - "abe60717a73dd6889a3f38cc988e6c29a59475240e23b6fa9eb647f2e40c42fb", - "cb0af8d891b20d48d23e2f213914030fe4c670bf5ed462fecb6633400d8c8973", - "d0dc2ee20eda05d11457c84aa624bae023248c189d6458a1b6ab0ce8e87b544e", - "b27c3295155462321fc9b9905880da24174ba6f8c44ad4be488a6cc5af629ac0", - "eae4cfe7444dbd3cf8ad3ad6ebccfa79999edb210b45e7b9b6d86576c7edd3ad", - "fb1e30e00d0f3d80872740c7adb55a64d248021c8bc0e42c6fbe6aa835dd4c34", - "91f332c422081c6f3dda858fb57e8054333da82f6c535b53377660f8ae33a999", - "caa0c3de643707a2e2363c53148e7f9c1996d78ab2ae2a83916ca6371859ce86", - "06c5861fe5d3b47b6d05a29d74e2e294fa367f7cac17d67d0f4cf034a227147e", - "ffa9fff2e738689a985bb03d4a00ad19936cddba76a018aea65572ed93b00138", - "426dd284343c9c62caf0ae18b73b60cd029e5f2b5fa4e7e86d4fee77b3fb46ed", - "23d56ac59b6a64579458690fadd82cc49095a8288ebf7f68d4cc162a163b7eb6", - "67e987ba5278a01f10dbea9bceddd43f70ebe05f7d3384c8bd0dc60f357f24d2", - "57088edc67c7bca6b5710d16fb436070905d2e6e6ca66f1977c7a2326c24adb1", - "b2b8a44440a7137b3587bd4ef58e7bebdd41d1181901be7147ace1226bc6b10c", - "2bcb4748ccc39d6a02c065aa2b5225a6a7e138e25008f14722e79975e684f990", - "6b4ad6c9911f27a4a9077e78de2db27ed16805f8b98a52f342d53d3f175e252d", - "fc07ec4605fb4656e0b22b3a4400ea9946090b84a2c0a67dca94b8c9517e0dba", - "6719f5cb6d7bcd83a685fd34856096bc321f169591865f8ad115ad594fa67ebc", - "512e56841887514ce5fbefaa45218f0c3552d5219be847cb4ee9801ffc541e70", - "78c5e266684be3a8b316d81e6cb343c5783a3cdeb2a8b4cf3d09f4753ef15650", - "f7bfeec282f6ba877d0e1af4c435f01c1efdf61481f5dbde9cfdc181bc027365", - "497ebfa6d755566bc383ae6711533e03d2e47055513d554388055d37cce95799", - "ad05549c277bc13483f004029ff702f3b91fe2785a57c753466ebf48f2471397", - "2244faf3c9cb1ee6eb0891521348a284edfc200e5129f05bf8deaff30be3c02f", - "b47ce6f1ce6053361fdf2d3d6aaf10f88a94554ac1a0256b72c2eb5543959f15", - "291f602fa0edf9708463da7afd29a9e1d04b44206f944b659a5f27a0bf83a57b", - "4576f8079b27fc3a69c763db4f1cd5f1042eda3c9db7fac80584679f000b09c6", - "278d4e554a21c73b783781a53dc9f6e18ccde1b8cc655ebf6917402902055d41", - "106812c0b2636438bc93a06aa5fd76bc402ea91cd1180c6031573aac42e53662", - "8957e82960e29460f42d473b101311f82bef700424f99afd514ace8cfcdb1eec", - "454796efb24031555e1f54eb4324dd9cc5e1a84d068cf104bdfde70ffda1d423", - "8eaab7fc4427ca9a367dceded599c8aba6b9c7a93de5ce3860e3a328a4ebeb76", - "69f844727416d40daab81fe9fc3007889594fa6c5fce797e2a97ebe4819bb345", - "0a668bf98379541778590c903e209dd4c611ce55b1c7704aeece3eda236b4e26", - "234db34a84a0c88b978a09865d333d8f8a03a68c662a835f9a4a090821a00beb", - "c2f10b88e1a3179c76f0af6e42ba8de21c1029b17eb4d9f256c159e1a9863dcc", - "6a56cbb44d8f09e383badee50c33ffb4cb893ec98499a195dbf67e4caeb75c33", - "f62fd0962a610a5777b7e4d06c11150a622a510e55b646af56e64bdc87a2f579", - "f29e504c187a4b512f70f9390f30a7ef59c6331b0ef7177ebfa2b5f5b42eea5b", - "e5d1bb4f2b6a6aabfd56c6753bd9a6830d9fdee4dfe7015e8ee38d994eadf1a2", - "aec01dbc3c9df14d2709a3e8dd5ecabd9a16487d09516b201819cc2a692bc145", - "7a4390b3d35ca7775c9be00d453c55960f98f821993a75b2a3625a162e3590ca", - "b02730458d3cfcddebd6a2ecfdd81d031104c0d185f749750ecaab8c68057e17", - "2a49873f66a0d8b2796639bf29cbeaa453ae86b65419b0e8263655b681c3177d", - "d79d30f819fffc483278f591e0c959aa2ee5e0ab1d73b0d83b6566b02585c183", - "ab1fe8fec5a853af3cd38c1294b8325e12d064210b88d5f2c091191904611956", - "34e38f2dcf1e9a07a8e0822a112ca0d5e1694d29928dbeb305b32353e7b79b17", - "7b3ff8f59ce06f122689556f0fb70fca95cb0136e776c9357129ec6e930248b6", - "8418891522ab768be0ddddcbb631e3402a12f23909cfcf3177e64483f9ee10ce", - "078b17afeff58161fc32b700c966cc4d73e60a3591b6d904cd347fb24c4e9e45", - "434116bdcb2900113245993358b460797e440acf9903e6ba4f012e45cedc1c9d", - "a39582ee090dae8bf7d6eb1dec87f9660368cd74454b17c3d2d7b8ad1345bc2a", - "61fdb3cb109a1cc33551814416b211f4570b8008144a23b43c0bb6a3d75cb21c", - "585bb60cf680cabca88b09dc93919f6c171720c407ae1434980e26d9a7ad8c7d", - "6c8c6ba25a1a25870f53e6aaa3e1dd6f991dc67b373d85c9ae27ad908d4fc9ed", - "5dba5a4eaaa93f2f65107d4995bce492249ad3c796068f53b31b1b7107b0e927", - "de1603cf9353abf15c5c39572e5c554c064ffe05536c67ecff1b71298eb7ef70", - "b0a12c56b3ca59d98c505939425c7e5df3b74455d662d97da9a4071732790f81", - "6b51bac9b71e32a46610577ef9907b2f22546c5b5dc5a948e2f4a54d5fd8672e", - "b4a8991038b15aa0dec531df7fa60c5cbaae1bdaba6c23780294d053a04bd923", - "a81dcaa233e3287221b5ac0763a61f2cfe759c3a05e791a3e0936d4d0681a229", - "277f5c9d0ddfc4d073ba4214f28c2d340bedf8e9cc060e273ce859511a9eba30", - "66cea987fef58d4cccb12bc4a75916beb651f388a710327bb04b8d4c37116882", - "e32bca2f823a81d861405019b139ac5555af12a6599b8b76677595267cb2dfa7", - "dc3a12ca3254e8008bed09a2b1338e9afaa17367a51efac476860e3d4e0a29be", - "e14fd8e5d9f1532b5f0d04a6f96e5d7c7a80841e950dcbf5b2ff3d6896f4e0ba", - "23d6d0b3f9b79c3714b32eba1c5e268eadd94ae97b2b8ffb0c449cb55e44f79b", - "ffa45e28441fd5d295faa03d528cdc43418654c513d13e9c9c0a5a8111d420f6", - "1920c7ba51ce23566d9671e0ed0d470291340a91d103d2be0a169db8bf901b13", - "74f8c5c129c0f26c19f099243252d730e391ba1f0914f61ada535034c0febab5", - "e4c40a65ba85fef2e29938b15575ad20f49b51618dc4bf797a40f02ec02c157b", - "6b25b564ff49cad60192f9cc1e827ce8340cb50d38f17d4e9d2b57a3e1f34020", - "a04a213f68dd29b906d71320b5f9842ca67b10cdb20d4214a2137a9f85286458", - "90a2fcea6bd9a252d8fbe93624275d41625a857fdb38dacfe596fc51713fa8f4", - "eb1348deb86e7102fe272752a0965f5d1f05efbe5963b75aaf169a919f8ab59d", - "65ac93624665fb2f18ef53f1e4b96920fa065b2b74a216808dda059927960324", - "0e7bca835b147853684843ca0cb1d7036d9c923c2ff5e3927a03def30aaa38c9", - "6eb8629351046b8b2280fec7bdabb509832ae0c479c5ef69eb67df751801e7af", - "d33a51787e0f3e107b3ef4d6d896b3708151a61c7d20b779fe20e65ee4d80174", - "56c5ef175d6e302888f3a43386b98c5e45b6c59866132106b341d33359cd1196", - "cfdd43b716e3c0b6b11b1369af1e65e616c0b4bb4f130a669f6722ce864488d9", - "4a960343f8ad676fc3b62daa065a5ce1e418c4edceda3a40adf338db8b34cea7", - "bcfe1f6943c66cb87eb9e4b3eb4d9a36c457f380b67530ac6ae21812fcb3db00", - "66c54e0f83d80aea962662df883e0892edf041c381dcf01d8e10d7e06bb5bde5", - "5ffb32276d8ee5c4b267f291a455481838c8c0ed5c98d83061c091af31cd6dc0", - "aa16b81f1dcbe8171e8a111834b026fc310f8fec641d1ca318d79f804fc2a124", - "7324c6eba4eb949f93a8a65ece3694a8673bf384ab693d1e09890ad7fa058a29", - "2943bf4011b06258e7a3b8c1d0779cb5a766f65022820f33fed31788248e0ec0", - "8c61ed033508ba80142794d7009e0fc73ad3e4cd11400e0b4b7efa398e2e8c04", - "0e4ea8db2bab026506a6d18d1cb843f4eaaaa9c7be8612cd06bfd6a7394197bc", - "86504135fc1aa4801caba1bb7793a820c148a6d4cefbe592f54e08ef2dde3f8e", - "78301da5fc245da790e0acca4ca23454cdd03be108dd069f36d31209ec47ffc2", - "0d8df6b77a1a44bc3ecbf7f64df73fa764832151c327e5cb2a4793b3591a224e", - "cdde7a7c34edce91e0d7025e5bf6a500b2b555048304ab3d85d26981c6451587", - "6c043a7fe10428742ec3447f3d7a6a5f7c360fd473578d0554c8df08a9d129bc", - "b66548316a3cc97ee5956ad6f96ef3f6546294440d428ce4d0c0d9627e315ddd", - "413a3d292b50c3bd8449365cbfc2b5b72d9ba844f8e3510cb4098ab6f745383a", - "6365d91a8acd23af54bdacf46bf9e27181665f8fa72c68d785de12d1aa20e5a2", - "07699516f442d7769b0145c4deaea9eb232840029857239401405ece9d5784be", - "f4ed5743f6e5ea722b69be65493389e343b1e1cae715feafc9308fa563970528", - "f160a9998dc5dec8e406390ec4106718df9be838adb4d0a3f084b33ed7d5c4be", - "9c17f1aad70edf87177caa4bb85f8c1022702dc5430d0f63a2e91c0b7cc03e94", - "09af01cd09540391357de61f6ba72eebcf83817550ce922a1216ed77ae94ab77", - "6f9a2edbd90320e5e4b642b47cbeb904ba33a5bafd9fe7d1a3696d46f2741b05", - "4ec5a8abbefd15ad6e413453fd0d12b8fe9d5880f0713373fb22a71ee02a26ee", - "7188fb4acbe7cff99cd15fd851e556c919f4a3d1142c505ef0b641ecda2925db", - "d9eb4994279630fe03b2f705c41f780e270d3bb19fd9a9269844fdd3dea7db08", - "02fee5a7211acb9e7abf8328c21ba8b68a839a6f67e63145f1d252aedb14e809", - "2c3d1c9670b9e143dcb50a5666c7d5f56758719ced5b43ca509836b060c6f448", - "ba9e1bf45ba9c3fea8c933a7db4dfdb07c66ab6dcd63426d95f182bdd492b0af", - "0270345d42b5661426b40404e437eba9e778fe2cc18e29e49310ee614fb7e255", - "3e755ade5764300d448d18d10eaa233ee67f03cd54ffe1e3084c6df380f3e29d", - "8078b7cdcfe5f3592a39f2f4eab079a9dd783dda9d176022e580339ad1f3f5bf", - "f64d0b75c10f92e15ca629021cfbab57651e4ceb9f5260836c0f3a878b7b2dc3", - "5a84c0a0e412da44785f1377c9554dcf82558ff3f952985e66e8135cdc9fde64", - "94519af01bf12980c72d4ff8f559cbcc2f1518bf8646605ea940481a438e722b", - "3397a93e2b1c6ef0a0fb50951abb41dcb04c8d030d75a79a56a24c312fd7b0eb", - "0b6a259061ca0126aeaa775c506f6819ecf8e9e0a3f829a306778b7f70058b91", - "900224a92755a975f2d54ebf7e5ea8d638ab3a3bb956aec2422f5e557f8c6e65", - "5bb52cc3a54c65825a5420095234214a94f69df60b6aa8772117be003a37e079", - "90d04908bca305acb770bfcd62ad01edeb872d2d8c136021d0471bcf1b682cd9", - "400a1f891c232f99487cc225779a3577a6620400fa1c2a90a0452c3dd803880c", - "0109edc5030c5632777326618d9ae3c00880c4a9a6494661c8bd4860d5bc6f59", - "3bbbb85759a8a91748ad55c22f2934c8301a19f8ba5e963c0ad87bb03bb0a731", - "8229829aff30531db00650d10c7fa22a5c183c725c38d4f1e01fc011caeecfb3", - "7712ddb865540846ba99c2a391280868d636fe29cfe6b51b3114d91e55387adc", - "251e17aef0b63ad44588507013b75ecef1d69daeafd77a61f850c6418f05b00e", - "9fb0e69f1e1c846e1d6da14012f8bf97a2ae29cdf4ad332a9802aa6d4b11ca2f", - "80cd77cfddf4bb7cdf453dc16f7256e73735a24606826c981f17e57ecaa89971", - "3fb7fdc876855419ed72487e32a1cccdbc93258a24bbd29525ef9c69f8744b16", - "b9a9c199ed28b7a612468441dcd7b1383eda5c4c1cb3de546c3474e9f900dc93", - "c1d1bbe87518064fdbfe95d9943ff73c19404453c6286c57672f8f60d2cba6b8", - "9e53530b5e761686e2d089b9663b7f15020c28bddef386f505eb144a48071a51", - "ce57acbcc1f0d7e9175d3a4a8658b289b4a4eea0df29ff4464f491dbcf0c2724", - "afd80287ea9957fff1ce700b185becb642a7230e042371be8aaf9b589f24f09f", - "b578e201750c63082cd5da4d85344476e3539786d6478c7027d523428a44c11f", - "4630434e419682b2f336b0ecdd7170b0d292c6e47444bb589c3218351346e0d3", - "bd283bfcf41739c3d456a3fe2dcf0578d3dc1c3152727be06c4f69fe1b973c75", - "7ae3f949a3f758eee6e1bb76662d119030008a7cdd0eefca75b26204a8465aeb", - "a43b00913fa2f3a46b331638fb1b702eaab4f048e9d33f0272f0194cbc688ca1", - "8079d181f48c461efcafd6c0a4babf3985bf6bdad28d51f4f533d78f7a2c539b", - "3caae969d76c9874be9f9a65849a59bac11ff5cd42d48ea7a39c2a1a43724bd5", - "3555d0b57cbeaef93dfd7e3b28a4c2c2b4ba0f40aea22b4761642b2cfd7dcbc0", - "d44a93754096928484298d3d7a295f3196bde72b0ba5959b5d1532dfae874cb0", - "fec8ab7d63ba07129d4e23c5bc15e6bc8f5f5407a0841eea8d924b51d221fe89", - "3e0948eb2a34ec5323de183be06693304d8dabf98a9d8101afd017dec98d511e", - "4167fcdc162af47bcaaf8d0f035cb9b4dbc033e6c2b831b2210e18a9a96c5d79", - "483ce1d14e5608a92e34c7727192d43a64f6af93a74eeabf11753c691c70d0f0", - "38d3195fb2def60a4e78478814a9007b5f24682935bf91cf3d309bff524be950", - "39546ab2e121ea07f8f09dd628813d97799313f23fd20dc926c60e9aac719b98", - "c314ad76618e855d997dba5fd32f503c05e5206688a6cc0457e876edbefff39b", - "331de8eb5f96247a2ea55d5ca3481f7cf111fb0fce3c17e05abe4818a292d08c", - "65b8cccd287f890167a044164bf4893e0d3d2885178d74c1017053293f3545df", - "49436f235f532ee59b31a1401c77505ce7d60fa96592a7a6fe8143b68e6bb16f", - "2a7c4918652a26015f49f67940714d3c153b10c70cbdabcc2206ba62f506b1c0", - "414a24d8877af1dc26294db4b901193bcd0856982ae8cda3bfd2ebbde0214a90", - "600b27a06787fdc27e1dba8cbd3507dbf377dc0ef9b7050c6a6a7516c324ec42", - "123ccff01a6c53a0322fcf0d3fd755b906dd5b5130c5af263020a5d5488f4164", - "71dad5f539159e212a375ba2ffcb42fa48c7f3be4b85ab067135967c9f96c097", - "53803809bb37bf129185e22ab767c9a21a388bf3820464d271265c6a1a6f6998", - "7ade721391914286ffc886ba4dea0094fc3228c880c9a321cac6f960ccc1e430", - "f08847c07bde473da493042c4be319d33f5f3359d1443c3ff9f89dfbf9dec528", - "e3b385e932bdc3494249356c327daa0b838a8a31c5a19545d731cfb5160622ab", - "488a83229873b36b241da7d216c077d1c4e8965e33a454fc2a41c132df92e161", - "59213a19a0c703d66bc6289450cc691d6630c89bf1a8190d0e989361a121db14", - "0c894a7414e2c6458586e73d21c319698e6f2310f55e4922d65b3087301e828f", - "c0cc1a44003a8b39505ef4272990b349e092c5cbca1a16b191062adbfec482c4", - "6fd7ffc09029501cf498f763e6f4a5e10e340f28b27d893aa802b43eb62af673", - "34b0461bab9bdb91043e8e5fae66f99efe1b72bc550d8b6517c82c636f26477b", - "75cf3715aa3150ff73c92be4611543b6215246e91cfeef0c94bc83e39159cdbb", - "0594a9da97559521d4e6975d493ba470d99625960a1f34fe42a8511139c44683", - "a8c1e4b175d7f7902039ed029ed58e158dba7f1abdb4bcccb85a9429c2a864aa", - "7beaa4fea80d98f98c95af5a67c0fedf56e85a37dae5785d2e05a821243f60e1", - "959d867e711d0aa6984fc5dd629cff3a114487b23ca3f412f99624d492a3d51a", - "a8798933729789ea42189305c3006dea8f5cad506cb8149e0d86ace4e68f0b5e", - "11550654e7e3d72f04ff77742f4fdec6c541be5092f691f089ed26935af50302", - "1370f40fdff7162d68a9eeb10a9217b2a57e5ad3649d90aa37eb0ab25a5f1ff9", - "a96189803764658b78af7901181f13e898eef78abc9d3a4d285a52652502ac15", - "fb618e7672d1a3c85f1ba8dc62df541adc19cf008819213caf41eb574dbb8dba", - "42312e0211f133dab9c832d619c97088ac3a945d321fa071ba50210b7a291d37", - "5c84a0ad3f5b1c613a4ffdd3a50cb655a42669b6bd85ad7bb83b459f3e2205c7", - "c57989a8178de412261725a28704f66d29963ed1830a8ea9b224bef02ade3807", - "ba893d5de01d6408d36df4b5f58b28f7d37f444973a97306c2174df92b6322a6", - "5520efabc5b4b9bc40691276f63a421d7e544ce57e5fd9037b1467245fb0be47", - "49080fc45008e739f5cfb72f61064993f3039b9d43380f7ad7961afffd19ad2b", - "09001b36b86ef07eac1dcb45e084294556c0dd559589c6f73711527d98510c89", - "42ab47b2b9780ae2c5b402e9f0659ed3d1391d5c3342c69d8410b9b376e2283b", - "ccb350786dae054c5d02ebd71b51910b1185fea2a5f2e77014b74ddb8b2cd50d", - "2677a46d8f39debd40656529fdc06ce69ab87a4239ec44ae5a952b888552efdb", - "a9702d5b2f12c40390fb9ac4adb773bb67096bf1c34404e7a5826e33f2fcb1c7", - "172d9fdf19374f114892cb2a6967f6ddc90b1bc4fcf7f8a3eeea2596417e3869", - "fca5c08c7574ebfd76d746876be3ab8c9d7a5f8f95bcb08b90fd9abefad7ee61", - "a80a6b6641c608071af1416360511f483f04b196650784f26df6d227ffb43a7e", - "3e011381dc0c30a1ea0181f9710f650865d1a7d8d815ccd8e5960adb21d77671", - "89e6e3c096b4dfa2c6fb8a90c389f1959c17b63fcf79c5d78f106f03ffa9b69f", - "b7f55a2f7b39791686e97ee26487ec86721bfa95a004c86cc2293b62745d1a9b", - "ebaa988580b15a617baaa0ca2a8a1e13b13da9ef85231cba8a4b0d30e8321ef6", - "08d1260706b32e0325aab051d576a98d557b7208c0a66a2ad4e8160d9a7cc8ce", - "b8ed320a4c399dce8b95536984d222e88f884663675234261406eabb90efc817", - "49a3faeb2339028c1315f961ffe4cbf7426c4a71460cadd416b606fba3102a2f", - "772233f5f7a0d2808806ee7c53541b8af9dca35b697b66348f1ab3e1934d0074", - "f6c61a66aa1b34574b3621bba37b58e671905ede5de266cecb7fb2b836cf5ce5", - "5390f1976ad02c3468ed8ebc94c0cf3d9fbc1aca720109761a432e4bd49e4ab3", - "6445421a7a3fce1620ec6a972ca78e1e387c87c0118d6e1d2287f67aaaa48810", - "bc510d67887a115619863bd6926150cddf7d5fff41c02ebb87b94574f8c9f1e0", - "6a7a6cccd2436eb40c66432f749c56c1e791cca2844042f472c72c28aef87454", - "f055c368d2df04d10fd3b9657f76d4b0ce8202a5d6dcca550aa943176cd35b25", - "10068b4bf7a3762e0456793a8cda2c7bdec613143f39e0d7e6f6f6433fadb6de", - "0fff610b3f319ec95964e3411590379ca64873427abcd9bb74656e46ca344148", - "4cc0947ee12b5fb8bff191160dab764c22ddc751c49a76a4b48d630482c83323", - "7c956421ddad646905c41278721ec43fa66bf0703c88e61375f6aaa529b63786", - "d45ec1726bdf0c39dfbd4169980d5b4b4f076b9dfaf9f53f2658bfbdf91334cc", - "5e22fe315467691602e00083674b90527c1bfd21797d15a64d742e877bfc0bdd", - "95b9d241a1c2cb96f9eb9e52ed53c50a780ef65f5795b3add0e26ee234833045", - "1c8fbbfbd9e6eea4432ef37815d5888caad0ace5ff38d39a0fbaf5df5bfdfce4", - "4343e402a7d0688bc119dbc468bddaff3b536f9480aee57f72f277d19b0b6a4f", - "16324a27ec0ccfab373bbd91e4d854ae091b2109edb68504edd884f1c65d8638", - "8f44d2fbea733f16fe3918db8f52dbd6623dc82b07f27c7027885f105ca3b4a0", - "e432a438d8231e30adc28a26dade610feca80a1d76387a81210d3f01aa0047e6", - "3d693087045fa49f4e1994ca8ba354ba77761829237eff3c9ceea4061bb3943c", - "0690c2863f55498f7c0ca00a2dfcf516e2b5010a6094801857ee60fed840f7ef", - "e00bbd533df149c58aba4b15e2374db6df196861000be4b871ec0694b256c779", - "438e02c71b21ea0a33bacb67714ab2c32c19fd14d9c0902719d062f34967bbc7", - "866c1f8f2d46c2fdfcbcd8899b3891bd6197a514440cf6b8d4d40389cd496a15", - "24d5636a396d13ea19249fb654a2648beae7798f8f9c659be01bfb326a79dee8", - "78641ec909367561e6ea4ee11df39b81690e32529d833a8b5ff2b8b440d3c89a", - "5a93ed93cfe6fbe0dec8a115f7e94e7b4b42a4fcca36b24bcac9de5e16e7ff73", - "40ffbe8da750642ca2703a8d79b605b4b8a4c2c2dcd45a1f802ac96ed61c2a17", - "58f958dad21df617b8eac3e651085991ece814b9bf8b42f75358cc9c44bf6cb7", - "ed426a2a9f644925cc76c763b745a94c0e103efd64d358625f4cf9fd165d38e7", - "033dbee5e0d866fc3164bc3fb0f75e6ddca88d26420d1dfd026b7419663b8f4f", - "edde19f6a7e5b7a5867beb1abde767535384c1a1bf91b146657e3a4c9069f58a", - "afe2eaabcaf5fd7b26e9f7637375885fb6f2d0fd26d988651046a6006da36941", - "83a51e423e589cc2ad00fde729bd382876542278b1b239c7e47d8532b5f4d847", - "42b165f2b220dd6139f00fea73581a342d2253810fe0a979d65ee668d4ad82ba", - "0111a4530474519c340d2bc3c9d90004b666eee15f4f22b011a45fed54fbb26c", - "276585f3795c45445f11d48730daf56312a216b7f5ddc7610426823cdb9def83", - "65394f36c2f384911cdda510396913a2afb2a20bee1a75238acf164b0e52c683", - "97711284cdb5f78e662ce908fee040faf19e37a00d6692c7a6ecf9b0143e6afc", - "f54ee960972893e0b09ea905a425c6c33857a4a40b848a390eb20aa13d1814ff", - "bc63159ed83fc06c2d921febd0129fe37872bec1ca4cdaa17107c41eb66ec6b5", - "c7129ad3398579d5969264bae0f5dbe075873638e1e0680deb4d68bbc0ad9f25", - "47de1f5a34906212e32f3f6af2146a8e11ff32386f2ff6309e6932eac428e07c", - "b1e5e4335a4e09868b8f23e8b8fae5dcf7b0dd35cb5fcf3965f1ad4162874f58", - "2cc7b91bcb841d6af3e45c6dfdaee4f81645d1b6cc3c79e071e55b259b4b4315", - "c5bf3946b7a346d4c4596f808cdf083217660aff8864f3e47ca869cea384dc06", - "fd68c1293d21fa5e9150298222daa3f90847b3e1f877255f9767c259bb7820d3", - "66c728daa5a089a2f045aaaf365b283512f5305c13a790bf0dfc6d8d69e95f1e", - "63d4a74ee476c84e2ee5a0b3341cca8d8097a76fa58f9893688882a3b2392918", - "d9de6f992db8df1eb04f101b82ea33fbb52ab7054c238eba0c8cdb0b2ce3b864", - "7314a1478ec47e1ccf478ee629ab273dc820460f97fc0c2de1ccfe43b15710f9", - "8bf84fbc47f686cdb4b6f73c5c7fc710e1816e92fccf9d61c31bab614ccb25a5", - "71572622e2f98e50443ceadcc5fb55ba438a8fbb3d5f6bf9af66c1340e23e7e7", - "e69f493333ab22f75565e9294a9e3ae460c7f523e79ab2e76bdf8c74be21ec87", - "f08cace2b013b94643dbd8ee1e14427ecc766a7743c1fb559a1b5ad71ab935eb", - "c10f4227d38cc19b6c6aaf8ca3433e639316207678c28834d55233a9c2310ec0", - "71cb50fbcc62694c06dff9f5a9b2bb6aa2399fb5fd7034a16851f0dd226506c4", - "b6fba7f0e0ba0ab83b2fad2938ca198c535a7cb35f16e116e5ed5d3c5abaa8a3", - "af67837de71c55058f5d79105df02c973d40fa0210301065e7c0500be0e3a51b", - "f60d0bcdbb9c99eae1f3f05d7ebb8a949f41f8da80a0bac4d7dab3dd42553161", - "403b7005dd7bcf5f8c3195086e4581a7bfc1a810a5f1f34cfdab09897f1431c9", - "5d55d8ad7a719ba487c418a184814b65ce85ccedf3e5f1d793f1a92167e15138", - "0da3f39f14a877503a3e83951967bbf523f5788b4eaf2aad8849fc5f45fc7ac9", - "85513a1872f2ff0b0721008f60a49c1a392e34cac5a3ea25848d54def38ab7c5", - "4acf9ee2111e86bb82f6248389b306770af0042420e12d16547954d0d28775fb", - "1a8ddadaeb9784fa117e21ec9e80be6da04aa1ffc558a1853898a22d8f2fc090", - "e4c3cd0af6c4f618e55a51e96c76df2d0460672715508162a5a85c8a00e70c21", - "978ff0c303fccfef89571f57985f8349507a0c1d2d585f0dfc44a4cb4fafd1af", - "5174d8cbda71f837567a495d08d4647b7d6e490e4814150ed146a0b429e528a0", - "7594cee3b7fb88685fe00ee8aa1827abb8cfc2dd57b70881c17b0fd3cce2f3a9", - "372e3c3d90506c64bb867aa7452d73eaddd513a4b4ef789ab06650ee20fee844", - "404499a5c687204feba5c81173355257692a63a04279152b1583d382040d6b40", - "d748c7eddef2518b1204ca0486c7a37df9694ea75b1c2d9924a430feef4f7d79", - "8cd0be7aa5fc8749b6ce541ff5eea8e0078e57c3ef444ed045d6b81ae4c89e58", - "d9d8cc9b342c7cb3b7c6ece13055b4d3ae1ec657589ef672d191bc6b178f398e", - "ef8546064537ddd89f18e19cbad10bb6b06979382fd16f3879ec39de6942731d", - "7684b54b25bc614d2227365db75fca33f396372b6533bdffa73cd7666fa9b9fa", - "c2b82ac97473349d3c711eb25e77c58403aaee870c355c5c91e804b0cbe737ed", - "066ad4529a4f0320772eeb0c616e8f24cf5305e25dae875279e46b02f6bdcf26", - "b5bb4a09729f97e1cc610f19b9f8d323fb9e7066893f4ad5c35c879e05ad8388", - "ae3e02ce1ff0f83e5a5363f3c0d6140e5468a61a11726348978d0f53ccc0d895", - "767337cef3327299730883bbe4b798a2fa6488e1e57db548540d531add6b8e31", - "7b547f7522578d1d78193e3e28addb3d1cf32c08c5a0414d2d9fa334d9b6dc3e", - "d426ce29e75608ff794569ecda68429821eaf76606f35566a49e8cdaedaaf1cd", - "502067f30649eaa2a70da1433ff7319a60f0c1526d631bddfa5d73bacda112dc", - "39b529b9f6831d9163f1ca5abb8163dce19a3b4372b4e83d19d65f5cdb0258f3", - "3bce503fac1b56484a2b941c9daeaab690a185f7d6f6a8647ffeb3b74c5c9c96", - "2325157f304c0bb3afe17e50dc96e1a39b7064e108ffe115ab20da1ca20124be", - "363f6028b1fa244fd79104ea36b38815b9ce75222e369cc1d4eb56d86e37a12f", - "bfeac832d4cca25b3ab8be9a4d5f3ee48e4d059e3a0fb905b35987d3cc1f0c6f", - "5bffd5df421893bf2295f99681fe5bb6eb73bd12c500bdb4fa550d821ed49f57", - "39d3bf44cae6137b80335658d176d7c40147893e1850c832469d4a374303064d", - "bba4a221270c4f4a1de2b01d3d5849042f33b261af06eb1d1c9c5774eab35dfe", - "6c78e02146800ba9208886eb7cf229b775bdae0b9102e6e2aa1ce75aee5e0eaa", - "9621523ac9b5d30133b99f2902d03554940eed4cae65dc30dbc1bc3ded84e3cc", - "31d66faf4be7644343dba8525235fd472a2f61e35652075be261b8be135e8cc2", - "a4883063652637579f2e17b6291c2e745ebe200ecc8484973e21d09fbc2c37ea", - "f24e384790e5e1b5e2519fe59b633b210f3ad5d8fe31ddf983e3e56c96928db5", - "78b3696e777313da97f956dbb7d402622998e6145afd16edcfcce042ecad2238", - "754862e57512ab1520992120e0e4775b3b031e6b3cb5b0a87ab4d5fd2003fd40", - "57b67f65fe238e41ecca201c3edaeb230097dcc87d522c778d4898d412f3047e", - "1f6c8867065c19ffb9d9cd078112be166cc9e7b92570dbd88e748adb71bc100f", - "adee9d9b535bc7811144943a97cd6c1adc56e317f8e4c30d92ecc94e0103cbaa", - "a38a01e26c5efb1a9dffb8632430b7519daf139ff3533829f8cf3c347e364bc8", - "e6480cb2a9252457172f0d7f0d70a5cfa2b886df771b623f3cebbc2583eed279", - "f1fe9cbcf22c7484feb21cf8b6fbdb8a7036958af9d808f3aadff41626ed89cf", - "baadcc6133daa0fb043fd9d65785466ea53a506809cd3db4a7845426dfdc16e1", - "238a5d4d2c06abf6facca894daea99a4d543ab384a7d8310b6e7ff8f1c4646cd", - "3f99bce86f6fa3d946feb6e7cf96c348b2fb19121030a3694b26abbc4ff41b6c", - "737ffd9f8a5d9ec0a4779c4a62a39a3be34b330477bfa35e8137524c40619d48", - "6b785e7f91e33aff48b1fb38172c717b0b7860f7ab2f3a55486c9db40e8f36aa", - "3190f77d77783fbf51808bfb504116869816d43a372b86ee8e96354b13fac1b2", - "d21496cf54576144797324d1378ec4043f55360122f354c2e396362760eeeda3", - "48372a50ad853bb56bafe41ef60a5c10815660e6aba67afc74e6556dd70b7716", - "a0d53cda87049cf778d9c74cf84694ecaee51ebcc229e1efdf29e85ee31dedbb", - "fb2e7c5173148b9076eaa0b3b880a559e75b30b3509fbc5c345d00c50915c79b", - "1a1919f653da43af225dabb8a3e855521769aa963ed3c1803067740b74a676db", - "27fee21fe7522184c3ba02c8d72c4161d63c48cc053e1f05300685437582f0b9", - "a123583934935665e2d8c4f97b04e2480a8b8543634403e90f276e1dcc1143c2", - "7191d7788ab2b6b94063c206b7afcab411528bea671c57ca6de1215ffe8d7c18", - "4d9437d3126fae0d4daa7416a31fdcf3a5ff61255c435d0790f9a6f118c7acfb", - "cb34352156d9589443f385ba0be18671adef0f45cefe02b5b98d1b73d98f4c40", - "c329bd9d1bcf4a6d1199304286571aa0d60d9dad41b1033fee29d45029ece11f", - "f2f63aea5dfefc37d5ffaba2e4407d6fe819fd419e313a2069f70385389ec5a8", - "99b7e03d113a730876871be9f955410bde97164f322cb6e193990e8ff93eff7a", - "8b91092df5c39e39599634be4739a575e49474a4af16ed78760f1839ace405a1", - "cb99cd9490adeded7e88357122f93d607d0a00dd92c355e0914abc32f0dd0e2b", - "e991b9f06429482946b5f2f064652e229c744ae78359a2fd7a043868a31963ef", - "4302140f21099e4e89f8185a5cb34e760cb658d44d8c42657de07c4666e60b86", - "92fc42b544b4fba400057197f396d991f026f173931dc8ca92f654cf8fb40b2c", - "16214c82192475e343fad4efda5b44ec6418273db775a539c03f8bfee4ddbe9d", - "45585552d946e61043c1745cdd58b4e17543b371f938046d49ac0d4cc62b1115", - "1695dea7482f45fad1b5132f98dca5178d3374b4026f85ccd12be4d2fdac8a55", - "a0e3c58629dd3229422cff6ae42105d627795c242c44a5d4426c8f6ed046bc47", - "429408f7bfa73d21f29c73dfaa8f083880e5a51e16a8b8c743cc6b34371b36e7", - "9388c0003535d192a992044fce1049be87f2b34d4bf7c18361835d4ed583f7f6", - "28617d3ba0f9be531bf62e04cc001966d6bc4d2b70ae2944d10bc13d5c72b3e3", - "691796249de0d39d25bed4c435ab9cdd35e8abc58d1d1f60c08d7304939df0d8", - "0532ea04763d02bcb89818591cf61bd83c7e98778305797329722ebf997e8db7", - "f3593788c41b13e1f146866a01de1b62101ef4dcd74523cc061cd3304b2fd234", - "46f026706a2f5fbd080198e494c9a4da6d55fb17e22089864f4865fbcec1716d", - "3605cbec3962e20421de3904643a59994fed85b67efcbaf80c7652dbb95eb2f8", - "511ad81df55b0275e14c2af06b94beb4aec60b7e5588ae2dbd348122b2f6c452", - "3d8781c923a55863bf0325be97f1a8f0396be0572ce0407c4278f6582acd5d75", - "5329452eae1b3d6706d6307c2eca23a96d12b3631dc6c235062bd95e23ec9f93", - "d3fbb7ff4b61a31eeb2ed6dbd6cde67c569ecb23072d52c35f0f295f3da54df4", - "a252c306884c99c5ce2003063fc3f1618584339409ba15cbfbac19c8bed9df71", - "ee868aba6aaf070e53c908980a7c186e78c1c3afe6409bb7aea05cc4cfae97d9", - "1c6fcacb547fefc2fcc0859778a6c44754e6c15714ac2a28402f4feea3494a1f", - "0a27aa68ec8aa0e7b5d2ee118f153054e357f89d8e3adb56d45b8bda5ea6846b", - "2e42832ad90126b139553dd31a7b8efd6ab52c408358df4c3fc608546cc51b28", - "1ee89fe91aa04f63e074fc6be89a1da961eaa0ac7f1db3a56c8f1e3e557212ba", - "166a01d62d6506036d3e770357b0813ad51cf00c7d134c13fc13e13d0ccb5c60", - "c7192c57b8ac8b999a66db1f1be1ceeba1752f01be3051106025bfb01ff4b260", - "ba992732b183ada7369044cfc931805e89700279892cecd9a394052928a7f2bf", - "60991fa7cc1f34b96e6caa26030cbc14cd47301521d3962bacc7d5e9cc360d07", - "2c26c2c8c686d37114e13d1b713dfcbcbf915df67ce6642863f74138bf124d34", - "f933e1e1611bd599243a30c2de5d829c8656b7b3b2cac027981603de55ccb0d9", - "d4a19f898ed846b8013a997a20dbe8dcb3e407e39921efa026833a411d0be7de", - "ca786d425bd90a11dc9304b5765649498500237d5213f33a610fd500c1ab88c2", - "71dbe7d2c4185e385f2a0f656578ea068fb9b8890b4e67ed77af1b8bbc8ec36a", - "e50ce86ed0e5c5d2b330a0e254dc3bd27d637cfb18520e62d4323d1fe42225e4", - "c14dc82dfe12f1b248c84d33c3852071bd0607e555b6a88bd4be0ff60b629995", - "e78cd42468ab76cf6cd7b473c6baebffabf4396a0a5ebfd9e6999cc166799f74", - "13b84b5e904e85745d417646b95058b035877c3ec571484ebb8f7c1ea0ab7fdf", - "1e069a21a98de55d3fe1b4f2863bfdbce16e6f8434d2d32fcf43bbef876c1a19", - "1e6477761a722c473c7860f1a9915303351057f43315469179510f570b94935b", - "a8d7f2aac79207bde9b2047bed7d51be952152a9972a698d5db7c1d060b4d7b7", - "4737c407e94d62ac9ab72b1d6936af3245c3935248d7fc5cd6e638c94bb25418", - "0cd453e05b646f71847910d8a10fdb6837b4a11b100794250caad5c1457531e7", - "615794ea24979c41aad91886857a5e5b998722d9d83550fede11ddd7117c1061", - "ba2fbfe4496d49fb93a3ae771ae8471d4bd402ad7ecab0c364d65471ef6c93fa", - "78a5204a86afa2548962620a804c8afb21991bdb0956207e87f61eede11e2450", - "669a93399ae12efe3eb287c4c09bb092bb059f56010028b3b880722c13e1d220", - "928d792670ccdbf9940e3dc9ff905cffa71c10c642d7620030d81b6c7dbc4213", - "4f06e04a723f33170f1c94f6b376991c293ec06b463a370e188961aae894e524", - "5ce6d5034ee042f34972709bfb78ebd316889e314c23b3347d1b3c1ac15a590c", - "07ca36cedd3c18634aef691cd6dff9d488effc7870344e02e6225ec319792bcc", - "1f9540d18c1a1a1211cbf9e7774e20de210572843b86f617401540a8e0716dea", - "5ee0b189d8ebff6401f48413ac1f9be74762cc1ce3f8611a112407b24fa54b6e", - "b50fbbfac75ec5a68ea029bd3e24378530c51f7e3349badee7c7f56c5698b5ab", - "016f0170160fcea6a26e8e502a58e4857af1a311949f015446c1b2b3456ae418", - "6500c01d9c3f7faf77783cf136be26a176a5aa075b0c2ab95bb95a85a7becece", - "95deffb239c1667ea8ab6e20e2d8a517100548da89b4c4636d7afa7c3c59408b", - "8f868821ec721dd1e0fba1c54b773c42d45ed1e37110bd8a67b04e714e69f500", - "a813f6499d61d26fa9211b633783885df26b0c58b289b43e99856f12920205e8", - "e12b96d8d429133ed94a5dbb034d6f9db6cad26eae49b7c2a79a6c38bf552b76", - "2f16db282916e80a279fc95585a958395653ec655b172a7ca0afa1084b7015bd", - "c8ab1bc3fb8af842b540d77d9b008f835ead1ad0776c82eea2b19ceccddf4ec2", - "b32937eda898c27ff6f11f515f15221e2458bc2187b78c811b69539169235648", - "6df124ecc49bf37f8410ee7bb9637f0edaa0ee5053b38aa6c4a3debfd2da6c4b", - "e3c06c782be3a577dd8ba09d310b93cdfe8d1007947d60476b0baa2c019b0d09", - "2dd71a565d25fb3d1f79446d2a7ee4125e54a7aa3fd490b31ab74186d6d33c0b", - "606b36a7aac9343b4e7b9fd2bca21cf27a287ae66120175dd0e2e147b70ce74d", - "736d194fe7ae94a77cf2ed1498d72e5b139e3182860c940846f002675d1cf470", - "80329d847aa70d8d66ca0e2ba806568cbbfe4864d3688fbf87f9adc2720dd9b1", - "b80236d850e1f809e5947f5fc4801762edc92abe784356022b74f8338e4c8885", - "40a08f6754089f97e90a7414a7d601a1b1dd7b529b920f1e74741017c34f760b", - "f9316db80fc98393f5d8b55f907306952a57d5d81d70d26147d743a88c261b0d", - "e70ac5c0284d8530c826cf5ee2fe2f3f299223362e55ea9d83a52a680aa83cfb", - "57ef776939c3654b2eff622c364541ff6a5c1a6f51bd4a4ff8053918c4a947b5", - "7f6346ca1341a77ef8ec0e7c254e83d2ac2df5d5721200cc0c4bc0c9760be751", - "2b33bb6156689b9e3bee9c547a7ba26ebc96878aa400c7999773bc917112d654", - "4876f871d542da6ceaf13de543fe57329fb78aa95fc39da9a49b745776865496", - "baba8d7e1ecf3b431dda0f0cd162b983add569a86b0e165fbfe06e521c535d93", - "4c7ed9e3462f2186aff677c0a4ede9a79a11bb3b4fa92dbd1b3e091da87a4e97", - "27af68806eded7b33a22d4a56cbe5a3d01259dea64647c2d424a3e6d10a8ba4a", - "db457e5dc4647255513c2d4505c56658dbb581c2a84b774f119f624179500e7f", - "a5d0f6bcfe584f9dfc6b87e2e6e91d32b6e7b0b2ef30dfe4e83bd2b3700fd287", - "85b49f63d04f928fd8f44d173906af24881b4a65585f7bb8c811668805b3f224", - "91f4f1beba636e2c8aa0a4998d47405f3a7a4fb1381f4225e6b4513decdc4d10", - "0fd8a0d170f5a4f27becd5b57b04426d0e8f06fba1a83c4a0446dcf87eb92f61", - "1e3a5ba20ff90b9e19c715f1d9d48a168f959a45fca692383dac5f62043edecd", - "9e5b0a48da95312bbae96d2e0b195b168e0a01f66474d1c07476622f0e28b8d0", - "c226b444dd99588f500c78187ea3fa972714ae5164b1112496fe446a1f2f76e8", - "a6763a4ec6f88ac4db3f4f58dda1f0ca34bd2f16ef692f54b436ea14e4a70bb4", - "b9c9b66f958b4948e78e7dd7ca6dcfd41425bc4da2d93d3e7e87abddb619436f", - "621d7b9785cb44539d6e4686038dbc82749aea187fac6f1eeee78d680f9746e7", - "efb34e98e55d9b1285065dec367dfa1132184eac6ba1324606f3ceea2e98946b", - "86d1797e6a3d0a2b6d570c623f75821ff6b2effbce66e85db7d79e2076c709ee", - "f7f147b80b19908c3284c0cc0e537e2dd7389357b6f820d1b78aac0554a4c6be", - "267314398d370a0b3cda233a584d11a5e376fe37b0367a5a573bdac2764725f4", - "4e826460ead1ccfb18c478f0793363e8c185bcc4a492994bd6974eaa75938fec", - "ec36796c607b0c6d22f9f9e451f50c46140933d216b6223c3150c32fdf325d38", - "8374592cc534a09fdd1f13b51f2f5c01bd3f22c13e831e6780363e200396c96f", - "36c875bb639f705dac2550600f132e695254c865fdaefa5d70620fed1ddccc52", - "aff159a81809e35b92ebde8be589e8651a789b60db65fe819465c95ad2198123", - "fba0f83621aae9ec6d749e63bbb0dd997b5b9fa68ce124d4cbac6960df6f637f", - "fac6df4cfff715d4ca38a3e5c81e395b1dda87a127407fbbd2901837d0ec63af", - "8cef7c600f78239abebf2b3205ef828ff5c01413d64cae2d3a7d1e2ed1e3718d", - "735e95c98a554e2d6f8266350db31e3ec22b952ca20d635c38ad47af3669a940", - "c599a3e5118019481d7c6328f14b8be3a8a51c96bf6e633a02eb3bb0e0461ffb", - "9a9f1e2bea5a5c1d55875f186376408dcc29461538e3d289369e93a1ab2ec9ea", - "d6c93171bc398fcdcfef39d6ff7e4de209ae193db36f006b87416040136437b0", - "4e05b5addc7c0a373740698a91031358f2323d7084241fe2474dd614b6bc5a0b", - "339c871f19216054372f348e9e3a9d49b1c98c60ef2b1e3a5f6471b94c2fd3b6", - "f44a97ede630654f5aff640e786062a3d735993d212e0c9da1c2ba1bdfc88265", - "d43a94a104c346c511a0a5f2d60632f442f68489873530dcc9eb1ef06882266c", - "164480bc9f8e73cab97d0fdf53b7a65fba059a1df3333abe5b689a4444959939", - "1b6658093823b88828268c503812220e2ea6cc90de3b2b68c93c262a2fb50c18", - "17ad46d885292a5bccf5530ab0ac2e060911a7a67336ec2d154398fd7453eef9", - "c276f44523bee7649950b3cb41ca69dd3064622b55996ce754ae62edb699432c", - "ae5d1f14dd4847135baaba60e0ac810b4dfd3f5b8468d51ab30c72b2393f9d84", - "79d2fd8fba3096077f98eaab4021352ed70486937f26784af607b9650e12bea9", - "18ba34457f8c67eb50a1b19a05bd8e5082663dc507b69d8fdf4aedcd4903e4eb", - "3f4aef4f8a65440eb17121bee85c50a5e2c112cd4d3b770db235bba7cd20214b", - "27f071bf112b2f57e36f6a8d859a7cf41e4903b085b5f676eb1b00f6009766e1", - "21e509a0852a651150ba50f2d94c95cdc344fc782853de33b44a0df34c815bd3", - "cd34933dc68657391e423d997a0ba930654ec8920f0d3698f4f16a08b1786add", - "5e0901d6447edf7f553f919238d76f759ecf808eca3d8102ce5a126910ca2709", - "26ea9e604857fad82d45e9aef54b601f3129002a15f71eb21134120d3b314b14", - "a14bdfa6d987681c5b3089eaf71559ffa45967614b5b4d1c68b34e78d342e033", - "06820fe8c5cf6e90a4d6b0d07dc5b091801d0fa182d1cec9ad21c59cc8a4bfa1", - "ec679a434ab08c87e81aef9b06735c73656e4b2a057b61892014c6b3486801a6", - "47cbf391792a7fd74db76a491f81d276c7c94d9310721c7314bf425012b88e7c", - "e11892c56876f05e849f3e6e1f20347dc1055f3c4e2ae5d9d79da73961d49d8d", - "070eb3b26edf503c44d55d28533d8e697573db75774045bc06986bab628c71e6", - "d6b34dd28981b72ec0e958775f75ec192b9c8a86b3d80e941f65b0793dd5e9b5", - "db46e799d20ea3cdf8948b46154cb5031f6cf97c8a70ddf180b14e58e26368df", - "c60330a6e3a503eb1a55d3df9247dddfdb243204686975cd3b6f7226f0d922e6", - "a436011d2c2b674e86e73dae49d6d82ca7251e80cbd247c052294cec8330483f", - "a630f680471fd55b0185efbae0d94854da53763d4f316c3135aa1beb3a5670ee", - "10fdfb0a3bbf4d1b16d4eca38ff4a60ee7ce052b9acfbfdedb16ecb2cd36d0bb", - "8d6fcc73959de5ee22bbd7436f66ab9b0b5875d6c50ae928d3903a4fc2a1f2e2", - "851a9fddbfa04a58553881e03a639634384208d5adec3b6e01b53b5fc2653ccf", - "eeee358e5c3ec9a23b7bbc79e0a1ba8dbc7bdf343c6e75f0022c1bf547d84602", - "64b31c6238768b5410cf237c56f0a060f6f71fe349e2d6bd6e334746c968abc0", - "23cfd475f51d43f173375d46603fca470a8a93f25d906c215baf43a0173d2d71", - "214248dfe4ec1343eb39808f28946593267521e5c49a4373ec4cfc55143209c0", - "5b55a2cd5b747a342b4e88b6a0d6b3dead7fca0e4cf6ca2a63cadae96f32b107", - "b5a47fac066a1db34e1464f0c1b1ccc7792b9c3f8efd17aac6a1a40822e52248", - "eb906e2d904cdb7771e19aef9252cc5c6e87460d13dd6be81873408a4119ca6b", - "422efa1432030c26af36daab029236500ceb2e268be91361a23ddb35ca478227", - "b524ab91b53a08e803188ca0f40bb9bc7af27bfac63f4459dc6754444acf1542", - "8e5b34a0a1ac29fe837722db37f9789bcc27328c7f08889d58bbb9a9e92ba9df", - "70a2ceb119527bdf331465145b4e8bb45e28cdb90469ad731fb1eba9dd57d418", - "32bf76830929bb632717fe0f9b600a3ecc8d1a7e2e250b53c071ca1bc96521ee", - "1c145fba3b88c8f8767acb383cb59887cdda5c60eeacef0a6937757041068a2f", - "99c99601c5d87592b42c1f5310ae0161c589d22d03423a7cf4e9bd0b844342da", - "c13e4862bd5ad06934069f75dcd0a635bcbff6d15c624cbbea774b67bc8f5fc1", - "9b4b794243e7db61d624e0a50f429df16ce91d2fb0f89bba752d7d060c70159f", - "4370f4261c3e9373112257f8575ce31c520a4a360067176d28dce51f365f96f5", - "0a494da095dff542cafdb39d0e8fe5455c598bff222935fd67e32434ceb1a9ee", - "4a86343d8ff03ee1d24878f4b9e15ae1b78892cce2f15b43ceab82e4447f6696", - "ab476bac044325c7039327f88a2f6ec2cb297b8967a8a328588243b86a665a39", - "4ec9bc7117aa3c2f68d224a6730d1a6636fd45c6ed32db3ed306dd14e93671ce", - "d83b2b4d3f5a66f5307a422b74d83bcbfb219e928def4af44d9384e6f34c323e", - "2483b39cd6038268f97942658ac5d3f7c84a3045a951fa163d1690ca3498efc2", - "e4c64229d62175b48d69267691db8d50d1e3953b2d43478ba4bc990629d725a9", - "756d9da13cdeea159fd60a58bd7f3ee44d8342e84bc4a68ec8c3767b479629c1", - "cdab72a50172ac01df64eb300a77a300d857659f7a0afc5a014b4bffb5fe7b62", - "8ee9514fe3ef0c757d18a8608c17ff8be889db4da497eb765e0a3585b760c10d", - "584d3d494aeae4d5e48131db03148048db172195ac25788706422301b3e1ad45", - "e84296385575a118acc07e395393d98701ec89808c7e07cb3dae0d0fe0aa0e64", - "ea8df5eef8c8dcc84bd2998c16ef044062f6cd0730578466a0b0aed7308b8a7b", - "107261962ae3bf43b814d4355f0f5ca4ab0bb4b86ec995cc33e6f67becabdbf1", - "cace5aaa2a426751a05fd449bd5d2d810767146eaa8b884d9a5a135350dfcb59", - "18eb07f11309bb60b2dd3a168beba2aaa816911983d9b313ecb6446c11ccd5ed", - "da95d9212366492074b02ccf22bdaa44fd1211f4f3798760e7007d24ad9c9ff7", - "fcd526cb15379b838dca082d23aee477b48b8a3308454b4e6ec61b2f448f3035", - "696725b7ca3a2f8b7a48cfc2aad0e7b2865088e1eab767893a8ab4afa2b03278", - "8dfb0bd4e89e49c27e9c522a8c1f7091bebfa3818efb9375f321320a40e3060e", - "e2e0183f71fb66b739915e99952d057f13bbcb6c3edb63649be2750f48a1f927", - "6576c5903530986ad9855271e304d76adaa134c2377eb560bf7bb72f6231c2d5", - "2615ff64d72b954164b7f21e3643b8d6b7e1d31f2347ca350c37169282d436a1", - "64f8a866e211b544d5b0c6d8dbef8e8c097a0385be16a5fd6c0d39c7e00363e4", - "d0094abd34de5f2ea1e7e3bd5f7cf42670cbb7611da9477502ae1a791418e687", - "43a633ea7d3bede907da8e18c80dcc0062a5ff395e55bc205d3d0b5351dca639", - "c2ebcb5790cdb1a2b35226d4246f42e65d4e1ad572f5b0f4e83276d9aecb23bc", - "449b3ab8631c849a1f500b5481b9ee4280b35c9ffff8fcefbeb5845c6d94f293", - "e34f0e06d8a4bd4d518479c60ee8517f3c2f99b00f9768c8ae4e6632ff41c29d", - "f6aeb9d02d7b61036d64ad0751ec55345175f1cfd32c9e5b3d25d827b30adf49", - "95dab89bb3267c2f2e7cb43eb2947506f5bb2e8a25cd9f1aaf999f1b80a635c6", - "2e6e0b67439f843f40fc84890cb34e9db6c4a8f0c191517c399b2ca01efa9a21", - "0878b08d41a5a491637170925850dee51925f89c67a8d21d70e1e4361592e2a0", - "6eeb48415bdf8902aed97bb557a143dc08844de1f899adb89b407a0d9f9cddd5", - "e41965ee7c19de2c452282e2195006e6b5e07853df6e1af7f02b107c378a19e4", - "55491381ad4a4ba5fa68242ddcaee17078c42acdce2bf0832cc63174d3f7cfaa", - "e4271db4daade501838bf25e974d3f9535a5940c4a09e0391ddb8ae25c414ed2", - "1500c24a00a38641028bb991fee9ddb4431ab06ec6b7255ed9f313f2d417a737", - "d78d81b17bbfb0cd35d135dccea29690fea885fc538a9549042227913141958d", - "e6f3e89ce1fdee07cd46882b1820db1d72f58f60d5177be7bcda11f536690e26", - "0372c0a14bf3c21ac31846fcd363b7040c9c66adf886dc5432bd76fc8d9f637a", - "6478922a12a92b2f5e2d1333364e164cfd4473bbb5f8304bc0f8225cf7b5063a", - "3882249aa3ae63e32b14c262eba92ab3e138aa723ebfa2a420d86e4d1e7e5ff8", - "6fd946c31da6ceacca1c7e921db28765dab91691a3ba6812cd5a7ad1ab89f40e", - "74759c34542b7ae1469df5f320466c8430c2d5e6a671dc321e0009f12864a077", - "4e779e0c2a1fc25701d1f6156429a6e5233f6f18b971f68acdfb789ef615b6c9", - "3d375a367990851b82209fb3e3d24bc73cda662f7cbe158c7005f0d8401d21e8", - "dd3d8ef15221568e7d53948767762e2019617addf18a4d1e4719de74fbd2e119", - "a68cf4f82be5dfa67ab82939aa3b224fae382219309fd16405fe0e8350c1d809", - "46c19b526056bf0159a9d72544c60186e02255d4f486e51fa8bcc9ec9126bde7", - "8484a0a8e4beb643e5f23eb44b42baa3d19e679b804b7eb9bb2aa752a0534190", - "367c82c606e71cf13569cc1c60660f4de0529c8a76f6ae9bdbaeaf2bd2ceb335", - "6c1a04509395c13297f1091ecc97193b7fe97d02213a6c9c23da5f76138c6249", - "4e01ab05271524a0d4b4f7687288a248b5f89b4fec9897654b5be1e70d1d8ad1", - "408cf4f0df43e8155fae53e3c34f639f3b59fb77269a89e235c5fd93d9a1149b", - "b2c5c3ae286652d0abdeeed83e65d6d589aabfb06d9618af9e1bb2f23764cbf7", - "84f537b803e0d8b1625a4c116c900772988df159aa2f79978a78515a8c9ee20c", - "812e95e93c5ef9ea48858cac964a75d63e4bde79d6ab07ed63e1f289bd5d6408", - "8c130ee4e6e40fb7c6b682aec64bd9ab54433b283a0f17e931887eb1889141bb", - "9cb8c70ce18f832d9fda576a8be43b3b719a4527b5448e2922035d13ede02285", - "3f1205ba55ac20016ef3d88cdbd63dd1556d950401090f4e49f14d2a63302f6d", - "b92c7d9103e38c461c83d60e88f54d382e322c17d93a26f90fb911d5d2ccaf1f", - "12c40beba84365444adf0cdc34974df8cbec873a816aee0426298059f934e2d1", - "d4d2403e6e34cfb3ea636ecb602b0c65df3261d21a5e0b25086f0936a39f11df", - "6fe8ff9b723c0d080197556b3c8217d57ea47d771ac10f8e541d29a625ff76fc", - "07540101bfd2bbae69b7a38f00d81c1fa7baf7ed500b63ce4572931225311d19", - "e81f509000e376fa3f1c06ace1437c63698aae5f4558154d2c547363e1b7109a", - "fde065a64dd1aa0862d998f46d082e06c081db89d140bf20b96c82b437a7574d", - "e6fc051c0ea77277519ef85223cc9976d258e5bde83ffcf3f8d8d91be37b2fe5", - "218f197b77b3c303593f0198efd9af8471f9460eb59f8a857bb2f3ae7345772c", - "5dba0f2c5bc34775b44d9f6e6b57a5dab4ecc84108e6ba7825f4af60d66abe0b", - "27b212fb458838bb77b89b8ba4e3783f3899c580195dc8f39283142a387486a3", - "0777502f98b6ab857d569a115ff53dedd7cc2119a07bdb27d677ba5531c41b2c", - "d9d0baacaea542ee775f05f41f3a5f1d89a4d9df7c608ec18c030a543e34df99", - "fd94b7e58a440a0af9b9aef475edaffec10de62864410487a0a78e45195886c2", - "ef88b9668370b5e51b7ac89f9419c03246ce4a5b4334c18346bf74f374f65878", - "e58074dd09005b89e2d63d2f2fdd5e3638b34695a76055c3845ef9eedea76a81", - "b23dc4eedf4d129a37b49efa5ec011aa117778126dad60ca8d5dd34e47e920d5", - "0c7bfb6a36163fd51cfd21a926332fcb8fc8e8d9c78a412a948f57861ad33717", - "55186223a40b3adb9fdf805a71d1b07c9a6066138f575274efd20850b5011385", - "6954e5f6d1213c8a62a65a179c12c9134f0109c6378906fe30238a1882de877a", - "df63b51d29dc2763f616d4f151f4fb45261dde2dd0e156af6d949fa5be754629", - "3f97c095153f2cc0a66b5402e3a1bdb2738bbcffe4213c204216840a8c2ea2cc", - "714b809bb1b0ee99acaac2a0c917e2e50a4467d71b06b30bdc97c3efa41e86fb", - "32fe7ff158a1aa4ef830593115830f9b9a3036ecc0f46db581b50d3478cfc3df", - "f42b66c64f4d0f7ba9c691c5bb46af935ac8884fbe379bd10cc47b2d9f2b0bda", - "ab6e13a52fe9d6ab3d06629074220dd123ddcf50ccb4289b2b99dc8211fc8f78", - "b771d2e94818282daa2f8cc848f79d0a3dc3245b9329d40ae2fd7c4c03fc5a84", - "97325092cf84d840f30756721e1919769c8d7d054a7ab0cc8ed15fe6e2b0031e", - "5abd8b6d52552078b0e4047625c0d022212fcda6438c337563e22cf337ca37f1", - "033d1fb36765974cfce9f154b21dbf4e440cad78679b39cf76aa94643e31e13f", - "d194a4ad5e0fca082d8f37d0f2f39030580a3453d4ab3f662495b799dee0384f", - "edbbca8423aab3d450cd1068f73f217b538dfedb23611df15bc803cd7d397240", - "6d231d55aa6406df957a1ab97ddabddc2d6e3ff53a41fd29f3fe6220383d9622", - "74749384ced199a4f5a58686abb7f45c5c591a7a2122d04ca0daa181f51b6ab1", - "9d454e741ff3ad29ad2645a93ad33ea8b5932743f1d6a6a30516e84b684f2ca5", - "8a93565a149a1bee3e7e22387b32f5de1cac7fc70feebcbf9b3630ea6d455ee1", - "cc2b0ecc90aa6dd4bd0d5f9a97db3a00c5a419b92c84ae50dc56a82aa41cabc7", - "62186ad2f27fc1b5fdac666f45c4176aa985be61e55c326f66041fdb9256f042", - "1d9ccffdcbf8ee18f7f58456bfe5bf92dda43de24f16af05ad160efd19285ce8", - "c9c3e9c35a214d36b75bb5785d05b053d6f15869e07ca3813d41d88603ab9082", - "521a12a336d333191d45b723aec23403dd7c0fdf593a1c0339e683c09746ebba", - "7a6a2dfe526ae60cba758a122ca2e29c32d0810aa9b492be1f3f9b70407b680e", - "04184a0144358cf84e47f8582ca5592c6ac430055c0935d1029ec7c404433758", - "c52ea8cd7aa5ad69f4a534ca8e62df8b2d8b187b506d33ceb4fa60e6c96863ce", - "b5620020c56aad80b9c2760f3595b81c38f1267492e912c6ee9c08ba9f3a8c46", - "2347684e78914de8cc62060a4f7ce66f66d76a2e1edd338ac9520d70346c3f5b", - "e2df784a99f5ed065cd5c4bbfe7e4a261c5a1b4086fe4546f95c4fa8befbfa5c", - "cddadae50544c763a139a99b28b22a82122d9aaf81bc3171be1b56e487a2d1c1", - "712eaa408e45b7cc47cf1aad4619c06b7955335ec6e39cd86f4e8548c72088e8", - "81a598e0289826891924e247204f94500b29bc15ec45016bc6928884c507f0cc", - "55f7490266422afd64dc931b3e2dc1d674909113c085887c00e7b067073a5c6b", - "cdff81da2c027fe2e4088b34a529f8505a723c72b3fbf02f87016951efc0c730", - "2c5bb8189d069b667f558938d0a5aaed7ab75e136bdbbed76b124272965704aa", - "aa90efc23e5b98643360d886ed1bcfbc1588723d18e5372333898e7138578edf", - "5692298a6433a77c275375a45c3070cc8cc8051ec745e6af82fbb40051ad86fc", - "e9d28373a640a818793cf6fbcf84af726ff2a0c2db8106fdfbc9fb54a691caa4", - "8559566391e8de6d23a0031c3721fe7b87946f64b2242746fbfbfc627de2a652", - "4fc27c6d5d6edf7aefcefa0c402ed64e26a1b6e18675071d9641c4b92a4a39d9", - "e769b969b4b122760bc82a4015d1153f4a6ab247d2ff6a85e30c1a8d7cee5bc3", - "370447ceeccf17192c639f50634defd1460c580770526c2c8161b7065961e813", - "377fee8a021cea17e109c5331df9788dd30c9e6c4f8e4622d0a362ff6666fd83", - "0c21bfb8871c0a20dc316de5964e3f0c9ca01190e3e73eef025e4e49a3bec59d", - "fb8bac53ea5e84a9388b8adc290487ed7b95a57e165f4577a0c23ca9692d2021", - "7138fb219128ba5d8466d190f51e11a62ef8249536bd9c7c14260b7b6333cc2e", - "608ff84dc0933bebd7c0e923e9dbcb4290bd6a3bcf8f5b30313d99a8602f794e", - "7ec5c5634d8741887c30e00dca172d26dfc642cfb711bccceb7608e3154c2345", - "79dc96499ac622568be5d51f8d1256c6b66b8c83d4fdd78acb991bbef7d5108f", - "8910685a75f6c453fbcf077ad67017fe6e0f670e3111ad895d5d0cfcdaea8afc", - "0e159b22a99db6fda6d155898c7a2b28b9c5fadcc8feabe0fc351adc9ed87bf0", - "81c003ebc027d131b71f42dde213e828f139c3abb820ed732bbdfdddb97afdbb", - "3a1c01f7bd242037f8f190d524714eb55f0e6c270c2aa0c2afe3ff359cc05ef1", - "3d5ed355c31e887756fdbc5d9858793e8c7822311483cd40e8a749f4ef519b45", - "b4bd1f56c4ab0d585a605a36849f97c901ee9a3aa006a850ec08d6ce348faea8", - "4b07042b5be3556e66c8c7d32cdb9a9461eebe872f82c273e5f92d2ebc968c7d", - "a8d1f62724fe1dc85e90581684199a6f7957b2120f8e44b273fcdd9deaf68f44", - "6d5938bd01eb46550119dd793aaf2873f98b538a258b862cf3b4baca517f7597", - "c11a98b68b391ee8afe70c19790606720668687e05f1d0b6853e7b825e19368e", - "0633ca7ec13ee9cdfdf9857850584bbc4c25614790f1894887787bb4bc22c02c", - "06eaff5db486220809885d0f1068cf01cd08f94c3644a10ba17418f89db6ac95", - "39bd866acacdba5e952f7cb1851761b72bc39060939d8f2479aa4d090471d74d", - "1ca6ca9339f7dd1f8c0c2ff1e9fef505c1e4faf42da47cf2a2eed778c20a686b", - "6c63bcbfda6c96c35fbc8e84d0e9e31aeaaa32a87f66d6d88cfe81dc31193f0b", - "bfbc47fc78442c481d18729a45abb681352541ce6e416c94cda410b751b6e082", - "e6cc5b860033b369e76b4dd74caa2f869b63bc1f92aa7685821028ad8ffd6f93", - "d45cb8f0030e228849f915023b3af2c5b7508be7113336743f7f1fa8df48db24", - "d9168a32a8f415eb78e146e7a7afd72e2a676edf64c55095c0b34bd2379b7825", - "ed8a8b8fea4c41dcbe9c29babfa61052d7b824e533c83aba250d874e423e60ad", - "fb5b854bad2263339417549c9a6b2235544bb2e0c77692043cdadc3deceaa86e", - "7076ead71a1f5aba5ccae66fa8c3eeaa2af96efccb4724bea74b809d98aca0a4", - "8f749f77e8709ed4964cc69a94fc2b171b923ca9ba805b128281d0d50fdd894d", - "398bf8e305f458cb90439e4c64583a2669cf696b9e012569d5d5f7fd0b705b90", - "47e6d1204976bc534844fd084638024783c67ae4930e5acf6c87a4a55e94d010", - "3706aca86246dd6de29df0907120ed95be97306fea6a255c02c06d02af53d5d3", - "4dda1923be8ac89231be5efcc2ec57e48c039a86ca3582799d102da9b53fd249", - "99d7da008390a2f05f292b3e0c119b70ad5aac0618b6c4c568921cb5fb2a25a1", - "b87dfd898be09ddcdc5fdd1668b3fdb075f088a28184ba20a25440f8d0f5e615", - "68f36deed7dc15e85ba081564004ed7e7e7afef07b15f2f84c5a2cd04f6bc789", - "0ffdcc3565c7b3d875a9a5af617ab8524ca599a2ddd3acb83718b125d039b8da", - "9f39fb10aa5d6655f391a358d387d37e620ca5bd9e5a3ade3a892792199246a0", - "a5ce7c3fa13cf6984ec968aac7e5df710adad107b09137dd4141f70ee34f49a7", - "10076fc5385df864117494fc878bfce6ac0b9e0c4123d1bb7b24ec61c5269744", - "338f713f422d8dc0108550d89ee710b4b27f833988fa410848035013c1f606a9", - "b44a3f14b4c220d5c00b97ea065d2fc11c02b5885870b414028a1f438e8c6fbc", - "42b44c502a9c6edcf639592a1a98cd00334db1efa7e34c44995dcc39dff9c62e", - "0841ed741c93f2fc2e404beb2ff2b487bca7f181181eeec91b1b53a621dcfd93", - "53a64218a7ca37fcfd5c64c914353d85cfa64d898c0eb500dd729d569427ab09", - "9bad7e23547ab6fecea8734316aebdbe7038306b5e3f6d7a079f21a6e60731fc", - "e8185ba9a76de0dffa6f57d5ab7f364bc52efb4a5adb4ebb8033f292bcff3874", - "91b6f925f0c948de44d807cf32aeafa4f8b3cb53739e9f08358df72aa4696a65", - "8ea3a7838ace548f1b2a7cc00d8dbe9448acb3291db5b80d726253f30c9cb39d", - "2b1c100f316a4369f138d8a418dee5a235c1b4aeeff178a04f7af7ec8a5f7ea8", - "bcd4a08122cebe7276e2f1138b3d9b726f74cd44fe4de54f5c6413dfcaa0c308", - "fc4d10ca921c84842ee066a77f34f6a201f0a9e81be5e3fee0d0cc1be27eef24", - "f1c54a98388d48c10b12dc0ee053bdbedff81ba90cb18e7b238a4aa88b4e4d6e", - "44608842372e35bcdc7c1df100c55a42b5ec1d882ece929da0df8630dcbf8ca7", - "e4ded72546f38061b8ce8decff8f5cfc0b104295561a8a9b15303dee26b6b4e2", - "9619ea05164d461f2744ae4cd68aec385d1eb7d80cc7c221474629e48b39c769", - "6cc01e0932f2dc27f2e6bb95e9d6c20de1be8c40c1ad17f83f9899a15d3cf195", - "0b01e6c2b9ec54a82ddcc1630c0aaff7ec74f148e46c7fa17945563debf4e3aa", - "2e3620fd6e251c0d15e70651ccf46a0b5d1a123187f8e3bfe112faa0bc7500c1", - "a4cf5258ae53c924dd36b54c4f1827c94d2a5f11885fc9016a29bd2de18aa555", - "51e2ac95b5c61dd8db313baa267ff7083a9a635c3eec3620aad40286e4fe68fb", - "b48a034ec4b404f1afb009e68e882e3b3dcf083b224cfff606f66feac0f54a79", - "2cfe2d8a3f01ae9f2424dca64476fdf681a66dd10522097f3fdc462c174846b5", - "562796f3ca354a09ecd3a3852436892d0b042eca500ed5e2d6e898a9e6bc0b95", - "513eaf453a61af9e09910cde55d81a5c689c6673b7611baa1ca1bf371deac70f", - "58d5c6b5f9471d648c29f0c4d09f35e3af3114e87309bf5a8d4c9cdaf32801c2", - "10690e0a1b3e5df7709d82d53b6c7a29a4f50452383d703425880e5b596b4381", - "4f4cbe24ca90cc178e4b072c20192e465367f2fd41b9055206d50adf5d5e299a", - "1da26af3c715bb8231056e2e318df61fe9e194f7ee738b4c8d33fd306ea1a466", - "a14fb97a922caf67316c8b52fa44ba3ad9788c7aa9ba487393a141325e2cbe21", - "5410cf8218e21f61acc4288d68f5cf244aa667605aeda09bc374af8ae93bb757", - "398f55e15bad4b98b4007c8c70d1ad0ec353aee7c878c8e8aaaafe4454c15c55", - "b78e7b4b4f118c2a734122472c23d062d03ac239272f965208e1e2e19fba655e", - "646b43b21ebf46003c4972531bace914bf0a6a037e22672388b6ebd9e1fc1e81", - "03a75bd8e2d714010633ae00289ca0591f4715d8819e28c16ce30cbe31f3a93d", - "a73c17be90729ba74055b373f4e4165259a57af6c35258d3c7a3ba2b7c8a6b8f", - "6fe87a44da00074d411d69c0f4c4070472ff8e00e7b4d15fdcd4a10575b6bcef", - "c526f4e4e4ea83505feaedfa92999722594cae10cecc48c5cc529e79ad39951f", - "8b6516805b6534720236fa144b2778e05edfa836996d198914a77f853d33b201", - "d76515a4fb74f45eb2cec495a39033d092b57a0a2d9c5fdb885a8a23365d2c34", - "281bcfa50c64d9e374903c65f079aadc7b52ba8cb34a46832572b54aaeb5913d", - "0142d4bc56a5d50f4c63a37e354c1331547fecbf7067e8db4d998623851d2abd", - "4fc9fe21f34f6171e7f238e74f605d170c9891fad0bcb01fdaca18d6173e3ed4", - "8893ebcd816321fe363358f8b937b287bc767da033ea4d366b6a2ff0f125dcd3", - "fa9023bb39884ce4b3adb04dac00ecee4297bb84fdc26f30d7ea7fc1f3fd2909", - "ee6647b2e72a5872e56facb47a3eb7d710a785da0b481ba298eda2a9a4646224", - "b9c1fa22d206a217ccb6cb2cc0e095ddc224f766d2a5eb1d9021b6dfb842759f", - "e1529493c7aae05aaa5024371288f6e8504ed2bbf2f0686a523c9d3a51f5211c", - "6481a19c8daf0ba42ddd4a0c1609698225a07f04b3a30bf2788aa6da99377c1d", - "8b2bb816b1fffb6e53b4d7bbb9e1d644720278361a25764838cc3cb8a30e407c", - "8f6bb682f87626a2b2980a57b6b38d5444c3dac39ced265215a860463370f0b8", - "1fe3cc54b77ada16e583ab2262e25797fc8e7bfc1189e33c79751dd2ae43ce3d", - "c91a3c056ad0c5bca21d82c4f5345c4aa54843be3b9eaf8b048bee5ba8b77968", - "e52424cae0b134907f15a62917deb9c2924e8d9443e461c2391e1f14803f65d8", - "4c8eb3bf0ceab17525413eae75d24371cf296e85bfce6065c8b3e17fc878e383", - "6767863ee9d79a453dbd69387ba80bf1ced604820fa0e45c5fb5bbc80029f5ad", - "e009ee4d859a4168b114805141c1d00810f90f8b5349e0465278f9a78385a419", - "c5a0b97cf5c47868bb24abc21616e7ae9bb0cfdb9a06a9434ee37c20fac3dbd3", - "b3b661717030a3b2f69fe3888fcf306c69ff857eb824dba40d1888095209c181", - "c515b0a1b4c88a964b0580d1159fb11d513f014d47f42a28e5bc6a490abe4b91", - "e10bcc0d96f26516feca641bd59b20e7f59d84a5c9277a4c7930118c13187ca7", - "571bbd4125601a1a76637eb11381b523048fd71e511816369e00e2c463a19735", - "bedfd1264e1fa7172d94a3427fafee189874b66f920e20f01baa19fb901bbe4a", - "5ea39e5ca1250321bf340bb183c55e033de92314a3e33f462bcef50c0c03cdd5", - "4e1bfe073a8907440c16e52e0713473a020657bc0527148684eab2646e0d23e1", - "54f0c3e2cd2d7232c2ac509fae77cbef88c4424aa8b0f263a8479d3ef5df76ff", - "b44594650f3329aa0296b4494858342e343e719abbadec961d566e2fc22a5ba1", - "301fe29d7f2268f73e836ef653560fe920f82f48f165fa4e0e49c0099d8c6424", - "dd3be8bc3f21e56e2aecf920560bc862c485ef0657b71a07a9c4c8474a599f79", - "8747aa68492c70a9c54c13d880af581d6bf814157be8270c081b1c8f5219e621", - "ba1fc6a2b4ed15c1e7bfea20abc3f8a7d14829fe3836bf58ca5ba0af336a6a78", - "7305a8bbb49f3f5e238d379c3d552f9e81a4aaa2df71ef858a30b73f310f8dee", - "b894c96f34d98994c681e8303194f058ae753062f1009972c45cf9c591f118f2", - "9420c88a8ac86c38f9cf243fc7d41e15d7c7ebb795f385e071e7016dc0920fd3", - "8cb72c35bde6a569b61cc3479fcb31348a4ced1c0faaadde12319b5caec9f1b3", - "8e714ee16be0535f520be4e213b1cf72c3ca7b7c0eff01e593fe8406097e12b8", - "db4827616b87440f34a4424ddbaa3ed81d4dc08dbec269dd4dad9c1dba3d358c", - "12152fc9dae2482ea113302dda50dcdb2544c4334038e31b068625881ce531c8", - "3b28cba2e14147570800673aad96051ab1e387bddc8009970fc8c80410943bd7", - "840fdb9809ab7ef287b989f3eb45c4fcf04df1db12dd744010cce8bd39ccce3b", - "3799730f6df0c71750b4f343ca633156982a520aad6b2eeb24a3dbe81418e5a6", - "fc952f09ca6768eccda34fc8ba356e49aae1d9cef84460327d7a2944c01037ca", - "4438235b35a3b73cad06636b5fa5a5a1d6c2d6110a4188e8f216f29c64635c48", - "3b74b91867483e99d12eb33f3ca8a9dc72af1bda83ed1c87eb03f0e8c5f3f0c4", - "79d8f05059e5b45b46b78ceb147f7e27083ae649717ca25bf2d9692aff045514", - "2164645e7fca323e7186ccc8055e5bdfc680ed2f4452779610adc747deeef547", - "2a9448f558f65a6edc3dc29bbd74f947bd9b04d0d71ff35898cf7d284b65d1a6", - "24216657b752ff786c9ca9f758d7240beff00bc0486b87663ac891dae73fce79", - "87e62fb739ae9727c22799a6b4968bb43b487e6788195242cfe2a31124151f05", - "5242e4c4142f0f68553e5e6bb16c5105d7a5af2a66a8599f254919cf81b3903b", - "8ddb9bc755710ff40b894b271d3aba117788c0aba5142ef321f87af19968917a", - "f79f9b846f0df1e524a45e902bb978817912a8d8a9dbec0374039ae094f261d8", - "0a3b961042c3d6d65cc355f4ca0039878b86a33a80663071f33d82553e0bb5aa", - "277797e27ab27e77a74d630c9bf013a263ee540c8231768859ed759bc0fae2d5", - "2b63ccac0b8f3a39e8075a294f3767cc47eeefe5dfb9d30c98ee08bdba629548", - "1ac09740be8aff3791f55bd5280d3e5ae622c50c91dd9bf5dc0a6229c10f8f4b", - "4eef78956931ab7046b15d98c91c1d68063da8e59e5a47635e86e4759439e496", - "76d336ad83bcc8fc83cf8cde81db8bacc7af89730627e381af21a00f96255a48", - "a53fc5ccc235e5f17794ad31df7195e32d390b722a82311efc949a17b90c4d90", - "b2e8f1b053e551fe644c0fdd21fb14b33b4efb586b5d04d8d35cda5fa9547ed0", - "a3d28f716c315be671ab5fa3a6da7ba42d297cc05099e6013a4f33923ea2cbdb", - "281412ae303d553ebbed4278df9d18194b04f44c86f81823685df07a69c9f48a", - "7e98e58c15d2f8daf90120c5c0d766e966d03a0f880d2ea63ea4840557932d35", - "801e93457c54a063460d59216583b3b09e7f4f87615c2caadc76c994bb229e1a", - "6a0083d372a7c9e4e7dac4f44c869d84e1348417e6247e3e2f922f6a06b8d031", - "68bf83e5729143ff6e788de75005ffeb146b19c422bf32e9efd14624a5d326cf", - "3153788ac1a79a0a6ed911c444e3e8384f84008d6cc6564ab2c5439b73a82098", - "81723def946dcf8a5cf9d89b0c772c7c281de165f012ad60d6354d4a7297211c", - "f1fc181bc74f03119af192755f8591912d16152c2e305a5adc8b7e3af429b6ae", - "c2751311feb3bba7f930420a02cdf299a5414f7d5f7a9a9356eca8e3de298db1", - "4f8c2359bdbea588b52d0e0d54d48174265653ac0aeb992bb5074d7cf2563536", - "850a58aaa2361cc78272239c8afcf657fc58134a402cbd5af4164fefb0f57597", - "e854cc9633bc04c8ee7ff16ae36e1edebfd3e7fe728e50cb47bb68e12f1b75b7", - "77d37a5d5b829456bedd8ce21a6bbbf96728e50a95d8f8e47254da52a5f2f1da", - "05365036e0173eb1995dee1cbafd6454a4c1e5402812463ef96da9c9a545f0fd", - "b67f073d74986805fa0ec49d41848233858e9015b592cc4cff97a726995cbe40", - "7343d08c73c7e83c59aa37e63394631e8b94f60cc67a9a0b55e7b778cf1052a5", - "141953ec0b29c3677d4a4fdef2514333ce5fa6616c641285062f6d42f822283b", - "0c5bf5d56473895497790f6a23f2ce4199b5e7141418177459cb3b776a5245eb", - "804281d013f228f3394420d0eb9ec1aafb868d8758bf633cf5c3deb5d71082dd", - "37440f26d7a98facb9b97a2a269df7553288325a982cf02895a4a887c0a7a3a6", - "dee049ab171627a4fee702031c492832830c1b43626fb02169bef20280d5d602", - "70148bb844e1d4a37b6048aa1c320d65428b0f714dc1c492f96c3579cec7c548", - "3dba0ed644dfb0108e085abc59f80ab86cdc63cf8592b19de659d5dc6249e9b6", - "a33756c06cc27aa7db02d86c35415f13b256810fddf47442d764ead92c0f31ac", - "bf835733d9ae570bdf094a0a59e9c82b493e46c9f37c7b0db9229cb0cabb1891", - "582bc0f9a5f5a7f169ce648030d94c5075a19298fb6e597ce36561b0aa5be84b", - "f0f118e27eb10eb4a73463f90b2dc9e6ae186f29ce4085ade323fb5def776297", - "69210731d64117ea26ab45bcdafdcec2fd618a7548b118a96470af4ed6d5bfa9", - "a7ed373215e65d448b55c5177a84c87cf55eeba2f2f2ea5e7066e5ba93fe4236", - "17a423b70708a7013aedb6869ade95bb31b14e038d04e24b91bfb017174cc975", - "a3879032a395a5834f09212f86626b6b4538038cb9e8ceaf205d94d8ff5236ad", - "988f4a26d242beac74d2d374029ad0c0a47844291b210a9dbf2289fd3b17a455", - "28e93f6fdaf7c6a9751ce8b793fe28174ecd11b1e54b2950f6e8ee82b9056a95", - "46662c8599d1f41f18a9bf0acc329837d033da58a22376dfda704cf9d1b64eb1", - "0249e556c28d845afc985d1c75b2c5334ddec2b3d05d3d85aac7852c99199f5a", - "a9293db8c76908c7657412093e2df4eed27f087c99edfd11b0a95490b90d5c35", - "5eb980915621030947b536ee0639c42f37246819924ce283b699b786070de83c", - "160a89a60148fcfb016f194f73a8da07c213af9cadf34bd433ca085fc383af79", - "26bd1806cfed2ab5bb321dc340a1c9eeb6996c7319defeeb10b7d990916cc309", - "46974d1679bafe11b1b56a00479dc8b73ac91f0b96842826060b3c626c860fb0", - "f5e2e60a0d5f597e98e0486695ac8f4ab193706eee9956056d9e35616380b277", - "84901f73f93adb668b0590bb156e84c0d0fe4a23d8e0bf95b43f559e689a0c72", - "42d3863cf24d6582273f59211f4dee051cc3f9eaf5108ab1dcadc99b57a5299b", - "a608c000d3d5472087466094eb9b88ccf7a50eb8ab374dd94239b9ebff6621b0", - "8768b713236960377246fc4de5ff6e098b4d6cc001bf974914c9a3978bf68a55", - "d5c5c7adb52cee91babb13068d49848e8b0b91d966dd0f8a75cfc6fbdad4eb93", - "bfeb2f43317621dc899108154281bcb2ee5e0e4b37b35e0aa9ef534f65c75b09", - "b501d0cb97ffe6d28a0615e7d5b5f9cae8d30bb65112d18e504f5d39aed20a9a", - "9e23da1601fd793cb5d2f5cb787483ea057f7807a702a2e618797625a46f5361", - "83478d079ab0aacf6ca72c87b42bb4443b58d0ddf86f5df89d33bbe70ad84687", - "1a0e57516390a6c8081291db2acee17004ce5ba0bfc67354c3a947ffb4dbf271", - "c813068d29420043de12d7dba7cd0ebc59d0027745122429abf245083ef78b40", - "44603d1fb78298901d44fbad85df8ab33415990911db2081a1749247324248f5", - "b93a70eea4c60795a33cc1a78555e164b47c3814d7d4e506331c5f71b35b2274", - "940ad91741bdbfced93116063df13df0eba9758385d60d8c9b62cf257dec174b", - "57e6690fbe46911d1133c3483a7bbb1013427e064a81f78b3edbc436988c16be", - "749f3d806d48a86103c34cdfab09f9b254814c967392d27c6a40f620b85180f4", - "539f243b98251959ad72265da4f6b4b9fc96a570f01dc8be5c5fbe71c9c9483f", - "4af29728ae78d7ad3fa3150aaa40915f83a33aabf79bdf7e045293361fc8242d", - "8cff761dc5645e069706bc019c96a52a193cbc7e6b6982da71f45ac089b1c572", - "ac833107eada1c17e12de963715e5ba1c04699e9fab992f7ef42235c1a851aa5", - "27d0c5713359ae3565cbb30a9d09736f6b72ac1a415816468150987f6b2bd087", - "f623a3204b28e53ffa04bf09a8c6826fd40cf02e14e3a1f5ce6316f80b468918", - "54f81a4418105e32426ec0ba68a83f6105d76b28a57a973d6bfdcbdbaed270fa", - "8ff85a7e370d6edf402317b9db9e9f1cff7558c8e0f647c0d2a057187181503d", - "a6fba631b6934f0d6be6ae516d07d259853234019a7dec3813bee53246e9cd44", - "7bc6e8bd0ffa55f2281c1116e25af42aa4d894d2d92806f619a4c8f4453d2f16", - "9b6f3ac939936c4ea4f02deae4a91c63c511739ae5417f85221355fd1f93d858", - "4449d07bebbb9331e945ddd1f2f46c4a578c674f7cc64577fa73f456d7bf021f", - "940d212c92a9d2abd1765497c51c0c535209b53968d1fbefbdd014a5f24930b9", - "236c31d57e6b5f39b47b396bde1e4e466beb34ab2f3973b4f5c51edd2bec753b", - "95fbfa2edac4b3da3a25c241a44a06704954d5c7a256f64c7e74419d1495ad28", - "599438e5f051fb8cd359b30c37eb2560edd9d92e6343ec0837e68fa29c362a2a", - "43e2982a4e23e5550593d6c8175d460b6de4282b79fb0c1ac6127811184c1383", - "ca9e410ae709f287d22f2bf7c30ebbd1f7731d123d1dc7eb71f550910b2187d1", - "a4797bf76f77bd519b22f6fbc7426561f6a1e80bb1367c406757fb6a4ff63b60", - "acdbf54c25a5e8e7e53a593146fac0e2632d09a9dd1128184b30da48fed044c7", - "856c761e492033f3de970707e080d3366f93990e5b5aa92781f19d17b7d36102", - "ef29d22f2a769a1c18f8fd1ff9e8eca08635c3a58d0ce2ebae849dc359984e6c", - "1aa0664cc35a41f625b50a3764b67a0242524d1bbac43d80692b81823530d100", - "dc176ebae09d5437cf460e1380d60165e312c77b3c980f12755ed586f8c713fc", - "d37503130294be2ecfe4568a82978b761b1f670961c51af10c2e748d1750bf87", - "eede6831a7581f78541c68065f562eabf72453b17dc1e9b9b1c3cd88340e7cd4", - "4033734d838c88ef029418d3b2418f84eea276fcab8e1cb2d7918a6fa1476731", - "e0c52ce197efa7fe8297ce8eed751b1f49fdb245699ac616842a4f06fe8f5f63", - "4b496310de81e5651382b4bb5e8dc86faac7139cd8f499e3fce61acea323d42e", - "9d5acb5059539e8e4a20fc68a53d97eccf61971f48a2e4a7ca70364325ae9cf3", - "41991be1351b3b3b896c0ecf7d2deb377dd10239b08ed855759f6808b8f5d4a1", - "3d17bb31fb4a8e9f6bb45c56ea2678110bcc5b9c3b198d4e1a1a8023255da890", - "9a957143b50ebb49b40ce07a541061ac45e3dce72506fda3db724d5ecd4346c9", - "0d30f3ed0ebedb7a870b79fcb7c052932bfd38d046b3ccd6842d157bb005aa4c", - "229a6dbaae7928c5736e7963c23f4ead4d275224a644d55efd3aafd54683fdca", - "54ae8c611b5734640326f3ecdd1f51f1685fb5af505d05c6b6bbe7ec6cbe7b62", - "443218ac58075d3a95d0003e86a055fb3a57f8af7f1ba3c4335c4428b6146e9b", - "de819576e984c45c5e7df2c15e6e66ce07bddfd7f4d45ec4a2e837bdfad78c1d", - "8107bba339b29bd33809d99542471d8d35a96c99dabaadcd9ffdc8fe942620ae", - "8fac2f0b2682e62cbf8ba6261d3b91d056f688aca8d66a2d746d8cfb2c97acb2", - "38b44a55ab4285a53c779c18cc953cd3048daba4498741868f8fdac63eb5da1f", - "ee2732ebdc019e3f566f9471530cd0c4b40065a417a1fd9194dd3f8721291d26", - "4c0b02339b7dbdb7940058bc8b0578d3e74fd245496cc2d7c57742b7d8672333", - "c302cb63acdc47dc3d58e156d4f5f5eca89779a622ef2925b3fc0d986f6e2e0e", - "21e7bddfab2a6c122d1118d2ee5e5542b30db3c769fe03ec4484b283d19f2372", - "16f3ffdfbc8e16ba93d0d4ffd35825571e25f36341667b45ba3610c7bc69b91c", - "a5214d2f94673dbaf9125548bde56ab81a3387504fbed3d96c94fffe94aa9b40", - "d7149bca7951e6be4b4a3a494bbbb31d40f81ec99c352ed60e0513d904fc2943", - "a1fde8854f1fc13309b5963589d839e93fd0ca57b283a47487df0c335c6b00c5", - "e220fb41b699868808a77274063259d890285119a22dc2ec6da2e044bb138b28", - "2679647d0cdd3b0ebd0fe0af3f8258eab4e0ddc83d0d6dfa65183dff19ca1530", - "b0c2279248548a71e75fa9c01ef0907f6d24fb958e0e1665aac99f7697da7007", - "ae2291b3fd12b91de6a19155e3135cccd77d1d3b15699e9e0201a291679e77c4", - "f8fb64a29e36865ae501475225877d0f729b1b50e2b7498987fe01c7a3fe23f9", - "6b65c15233c4950fb04eac8e47e3a5a5ec9a46c432d4de36fd86cb761eef324d", - "3f39a13f0ce2a7521da8ec86cb91307f12ac36d1de64b32b412d3ba42b295009", - "f4227e18aea389aaedb21e364311dea1e82a5c1470000d4b3fb254bcd3adb89d", - "03c6ed8fb6206d3c2da7d9fd178a5ccd0867bd81954363b19ad88ead0e89e679", - "07ebf2fcaf146924f04e4e8aa80e9d1f9a6ab1a9d886da9dd5312f10aa25f4e9", - "4a2a6366fa0ac9e75ac34b032087e31e51793ce18d3914ac097dc8a64f14fe80", - "011ae0639f183ad9f8224df1373bb5a4e571bc471988debd5d180a53647c125c", - "fd293dd95a623eea415b81ee0604a40fb52cb64f263b606c09939816f2072eba", - "25ec6fa5b06368c179cda7528673fcb89e90a7ab6d99a4383df746bd4d1de62a", - "8cc00999c0eeb5bc5071832903265ba60ceebb082c3b01099b762e3f1de06494", - "2fcd833de076e858aa6403b549b67a7bcc6140f130a908281e52c46a8cfeb75b", - "94ff8298c294766992b85d8e86ee0d917c76f4437b3bf4436d765469df354989", - "7435e27f261004b17a165256dc5d72edca26eef4cbab0e568cee4807c9eb80c4", - "2d117b4beb388a336c3702492f8a7efc204f1ec5b481ae9c01dc26b69d23b055", - "636e0c930314579281241ffbb23ee1c829dc350bfb8572ce9d74216a1313d947", - "a6fc63fc5f22312e219dfe8c94ac0111cb34155122a6c41abbe0265b55c1a647", - "ef8620745a81eae2f6e517c3980a8338422c9dbe6c19fb4012121a317741ab6d", - "d86c89ec6bff0ae04ed7b8d52cc375494b9ac133e0c8936986298cad88af5c9e", - "62a15f6777137480f831d9f0423bb3890c98f3a7858f9a380d393d06b685dce4", - "3ed670635716b06d92cfb53765333654108e5aec0752979cfa107372ec765ac6", - "333c47a4bf0afdff53da27030d74eef4a8ecb1cf51a6cd128acd136acadcf67e", - "180967adcc52d0d784604df238a2c367c46c2c2ff85f63dbe749f25179af75ad", - "8122864480f7097cefddf75354eefdddfcdecb2a48baec1a3ee56b7ef789d4ff", - "3d8a01d6048d7c90e4159d20c5d95290bd905ed1a77147458d0d1ff189715e82", - "4e4410851fbcfc3aef8f387717dc80d1e532849b169efc618095a7ce3112f9bb", - "12e5ee420eae7a63f9df25612c3120c6d598892fe4956b9cd6dd575e322085e7", - "252392b9f178aa08fbf4e8116a96cb50b4e309b2ace4ecbc8bf276746c52fd08", - "2511a8a08b1a520e1b82b6e4b899ab6aff09e967ba0e789d5393753e36577b80", - "bfe1c40f3b16084951dc19d9e27c42f811832a7789b802c085fdf606d608ab91", - "4b088dfbbb39c9762e74684d7777eb0cf4f0f7ce9ce8ac81869543d1a46d500e", - "65c89111b41ddf854a9b1f720df5dd6de6cd170c36ea20269f4ddc70d7109ba0", - "390a573a9ea6ee6a8967d0a71b7e20a160bcb343b77cdb1403ab0b3e428aa6d8", - "284837a848bd1a498ab4e2c7c4100386d6107eed3824fb57491eaface80c338b", - "002d7874e4bfbe1f2c3d6f4568d32f5611650b10fa2d582a9d7ae42e5a80300a", - "01d9a59ba9f63a570666caa166eef2d536ca024217d3dc826a348716a53339b6", - "1d4be2aa6a8b8f99dfbd688c80b2850e7abff1e33baf8a4abe4703d3f38bb1cd", - "5fdf7708466148322fc3d4c2789411e6083a989f398e621d350081eccb751434", - "c348c591fd1a363eca6359923c1048ef2c503b59d5bf05774a59928644c9794f", - "e929d07a74467992fb629360096da2394ac6b05d285e87692da9e355c9ab41b5", - "2b5d3129b846a158d37fd61be1864c5c2dd1695c3416774bf1e49ea299b88cd4", - "dab15443b7c1e9050eb867215b7c91a3322627dd4ea44dc31cd59c1921ff4eba", - "85a626083d30ccf09a2603e6620cc1e5f97491219a3f8615403194555294a2d6", - "9d7f81b873040b47ffa2b413575afbdbe823a828f7a02c1fed0296b133b904a7", - "0fd911507f232431234147ae3bb72bdca3122f2a1a56b9941921136ecaaf03c8", - "f68b07639124b76ab20ff1dd7d02a6a1dd953ae577d03d33a9e9dc24f4a05100", - "77cd788fc461f3abfadb8456822023755b9188f802fb03a131ebf09dd176b82b", - "e0152962b98d59fb8b9def762a2ae23d1fd0f928459b8bd08421840095a3c811", - "5657367d1da2da0be077e352483716e8ee04ccfdf24067afa2cb623ede8c8d6d", - "a6706a4823792bd37426acaef44ebc02535211aa313c266977dc472489b7a0d3", - "767c2727847e9cbb51c14139fbd4375f914a4cf169a36f068f5326adf5cda381", - "bc8ceda29ab83513dc6785a8c65fe6c10049290fd8187dbb2cbd8e43c431a068", - "5ad498fec33f23fdfeadc0c4c316ffcc1547f5075eacaa20ba7f60f79ea64e5f", - "df02f104a88c195a9f61eb3e7ca35771d1917ee46d6c6bda19cf881e6f6b1a0b", - "c8dd0cb020e16b17b5966418ea8bece0f914a013412bd945a96d6222bd1a805d", - "0f607d3332137faa9bccedadeb7272d73aa8b2d45d3ce62aa052887561b0b769", - "96df75f1ac291b5b9c70b967d0828c04fed37bb0e0eed9c32c42e72d4d032218", - "29e742bee3700987e5e56b3af475ebe5e8c937d8c3fe1b04310d0c24ed0e1c8b", - "fd873c307f67838964a0de19cd67f4a9c591946841ba3aed988acd4a555484dd", - "89b2a064e23354dbb9bbf888cb2f5d421f1ee56ee6ccb5751deab13112b6029e", - "cb1dd3ec47503ffca2af3d6db50619e8fa346271763f4653fcf2c8be15689e3c", - "84ee2906f83fb43844840ba9f5c7fdbef1cad5d5b2a28cd0cde6f517bb093562", - "586fb61c79e32a31efc8b193ae62a2958e8a1cb3b3cda99309d7899c5b96079a", - "48015d467e1551febc87f44b406d41bb52cd77ad752ff285e1765f09d3c956fa", - "02ded8aef82de603081a6073318835498e87c4a9814305926ce04d747d7b2917", - "8140c20a1c2bbf0eec738334bc55beb3d76167959c608c9781fc0e40869b4474", - "122dc6ad321b6418387484ebc1985d426c2291aeb4a0a154358e431ba8099fa7", - "c46f62919b7c73f7b2f534ef676a2d5967e291bf28edac7b3318244a89aaac87", - "66b48a5bdff228d2a3c8ac5558040014630b053f643e66f71484a94819fe8467", - "409eebd983d65028e152d49a0d184aa28d9e961b2bb3b7b4ac777e2a33d493a0", - "ebb64b84f65feca3b58ad0eb2d111d5f399d31de2895e9cd0b0e54cd3f49ff32", - "36d4c17ee115583d80dca4b0a71a3b7a21eaffa19c80bc39123020fb1c5e0e9a", - "36b2a15df839a4f14630bb6d1d264f9cdd8211e31115b5274a432ed8d2e54462", - "cec59525a75bfdda14d7c7e72ec01b6fc6e13a65a966cf087bb9b5a3f84d1c18", - "c765a8017cc1e03443762b5f627e131eaf56fdc3db6162e45ac4b204eab30e4c", - "66590a83c499fb7a73b2c0f4107ecdaaac5fe1723707f5af236a56148947f9fc", - "9c8168fe207a3892bba7df0018b996bb484067da65870f195de4543c96d4ce07", - "f2f6f6e6029763e83d17c044e9ae2c0ce7a6338f06489edfa213fb6ab073a31d", - "563586344235324e7e0071661093424072a15c0edbd59589877cad34d5270d62", - "a880e7336dd340ece7e828bd31170333933c1dd2edeab29086de243104a85c05", - "58f5d23b688b7212264a731aa82d4ad52e8722e511de386d5340def253274172", - "07fea4d4857a8a6cd2ac9a9bd02a010ddd2b45f5b9b8052f86410ec9364dc307", - "4b93b9d0626e46aedd99a51d6c19975902dda813a2f0f77fbeaea5742aa29ef7", - "1a35690eb9dd416a4beca685c56adaf296132269fb27fb8f4b862c8081b0fbb4", - "d9178c3707b19aa8221a359cf92cee0e9f3adca62f49eb9e7831e6848fb96e90", - "cfa83e202162e376713f0d740ee7e7a435950ea19f97d80cd8a220c9ba95f29d", - "65b6891320fcffccb2cd4e4a406a4e7137e7b897735d58167d0f855257b8d91d", - "6fe4973a27592b8f897ec26c8d3285354635fc89f5415d21a53f5867eba15b32", - "60c6d212e850bdd8aee70afc28a4036b93ef33b035e6f4902ffdc1c2cd242205", - "f3886c9ee1b46925b08772e4f25ad20e5d7547b3ee2017a8836f29c58c3449d3", - "857253aaf527dde456458f617a9d06b9b63857f192b2e157c66aad442a1616b2", - "bf8d45415215a40855b2777b167ae3d64c53a4666fca6151c72ae0de7c09f60c", - "072c1363aeadded99fa856c0627c3e0939e3c3dd8648964f0fa95237277778cf", - "4a21a1cc425ea87bb67e8f1f962f53d74674ddd4c92096e90f7e729aa3a78555", - "6ff509134b5d61468a657e080251bc81c95ea45280316f273425892729fb813f", - "85e4f2194f788456856e3873e4a9619a85d2cfa2781b9dd3a1910b0d85df4fed", - "774246eeae3b57b59ef75f3e0ea67c2c1191e554986b1f4f82b72d30fef15c40", - "d67943d9b65ee430706711fbb9ac0b2e3be005b1f74406892e4f6e4fa4ad0bb5", - "b0db4bba6de559408d42e11f2eb9083141ef51f0b5ab29f47362d784a1a15e00", - "910d56781efa2013133fac9d05681d3c4c9628f297fc12db528357d5131cb678", - "3a8af7545e29baf65710321df93a337f32fe2d773beb9ac6f7c4e47946e2dfb3", - "9c27f755cdabfdca56c3fd09d155652eee4f31d94005f37a04ee0567bb037c62", - "789ea5ee0e648101230b5e91f7ec77ba69c6fca1afbd905eda995859ab4fde3d", - "cdf184ad2a618762d611559eaf4b2eefafe57388d693a136ad6d3efed516a8f7", - "bf44646cb6b6a021b737dee18ed58bcd385b06366a8d6e7126302c89f478471e", - "fa0383d67bb95d7c22df666abd916b62cc43055cb6a85fa8ee0986600482b5a0", - "46e81373e8e9eca584653f6fcea36c60d1770937442d09653f2c56a7b4da14cc", - "29862c8f0aa375501ff77c1df95b6499f67bf6bcbf6b37970200f4964349816e", - "21214c6655e784771a6485e4c583d3a979c98d92923f0607f55316fd36c794c7", - "02cacf64c8a2a16608717587f349d7268d731afd0c422a74d15b2d5d94d0ff0a", - "ca6ea42e841ead1ae32d1e1944cef1897d121b00c8bf9a28da49f19f62dfd83d", - "660241dd4d58cc6a7c8ed2259e9c4b1e031b751a66a9337ac450d0f477ffeb6a", - "0beaa5cb68847d9ec77d7ac0e6878fe1f3bbe4a3f2ab7a0e5b9933b17d7d1a36", - "876f384afc7b73d3bea1c444cf70dab45d3b01090d5e39755476e35b7cc235aa", - "84e9798012f4c082bc94cfde845b6ed83faad83c3921dd93cd823a8c00d14250", - "23cd8a237792712a124603912a468c6e656766053b32f1c44e92f74a46e7f76c", - "97789c9e4cd35a51e833f935b643d48c705c690e8005a7bb26718b5933fbec4a", - "68bfc26a67cdf532753175c84cacb59876045dfbb003cbac006fa20640208ac8", - "f1c357bbf06685faf8d67a1d1f6a536d1ef38d018ece17abfb45db1a46efbfe0", - "568a02719ec1ab12762496f1e5a37e249a0736643b1b9e852c411e680967b00c", - "eee7e4e5af1b8522fea7cea940c368bde65e3b5e2f0606751e70e4e49fd149af", - "a1fe9f859ad8f220d007929d7611a26db531fa333fef5e797f2a76960db7d551", - "160aa2eee66fe2e873e1d43a45a4ef132d936eb383db71b06e5aaaed9d0133ad", - "ce46e9464601629551d3a1ff99db9cd669e93bdfa3c1c24ac5e3db6859fcab7e", - "8f340e79b0cc002c4a1d341dd4073b1f79c092d1b9624177aebc0afafd2d6545", - "8c9f4a434ae70c45679ee05786878610085952d96ae0b0c1ef0e1a5bf53d274a", - "ad2d5e875207eb10d087cdc55a519ff83b0b7cc831a05a6d054cc895da0417d7", - "40635bd8960875abc314f5bd5d4420b8d16fcde8a2faa5dd5b5600163cb9f744", - "07b4a2ec28d1f3ef3c0def441498b2d445eb19bc33543f18c6626cb9c9efe11d", - "034a907d437e4bee626d75b4ed375ee6bb232e36e37f67238a65b7ec592e3a23", - "29a383399a9e27d12203782c1f16a0388f8e3ef15592be93fa7a12508cfa77ea", - "bd125ac1908abfcf2215d83aadbe1a9bfc58b721f9efefd09b73c568cf50b645", - "bd1944b57ffa5bdb0833ce05fc9b7353689d536350dd6c241c93422686f5a204", - "c6ff1e49697c0c300726616c1b9a5aa302f1ca017fbd0ecd5b0d3bf0f147cd44", - "85a45f1adc701e494d13ac4efce08ed84a3e95e4fdd7ce9d1503642a90002707", - "84db106b103dd5f2df81843de258b63b2a9962be7539c4a170057793c28e7a18", - "57f5f23e2bec7ddea761ba6af37406d0e03f8f0affaca4748b8caeed8749e3be", - "d164491a5df6feb415da1484b381e6b2521a347ff3b3b3d8c76b1161af303605", - "77a9aa79438c05ecf5b712ed7f5dd64a284fb593dbc654375c956282cf4dde42", - "688d320262643364ab394c0d3cf5c03371e59236abf23f9c32873fef4d62b921", - "70af0196c72ca3b806025aed02856ce0c08c9b3820511714163a210d4e938155", - "7117c44d9e6710b9a99adcfd005211988a2f6285f87c08dc85784cd62f6b69d3", - "a049839a9a15a47adf1fad12c8b6c2d88dc7a6c267989c8bf77c13b63f7323ee", - "7fc27356e3ef851933af7f3d5c9f64deea195c750ba1c22c866fb645edf8fa9e", - "ca776833bb50c12284793c553a484f8bb7ce927daf91f13944e5b653509cb66e", - "dbbfdaff023239a102a1680eebda49243743e92361de127684cccd7674fcf579", - "111669698c40f430c8e0c9f245fa96f915548c5712b18daf1818889ed038dcee", - "b4a82c3b0819b7fd74b9cba1ece839b52f7f71eeae68a4e1ef4a78d7ef36bdd2", - "305c2ede9d54b012a36992b1dd82112d0dfa192cd8fa1072db2da098398e380e", - "56da22488e9bd56a507e45b9ecc206c11767e14ce261860b23ef99be2441c365", - "02567d979cfa67cc0e45756ae2020405deae3b3f7b4fa0603d62a62205ce210b", - "8b0a04efb82f87165a42e8803a377cf6fd36b960096b7c9f0904a0b56f2b3d98", - "3cd06354c79a3bca139dfb798c8f6176edae474f532103f016c241bf53a1dc31", - "42bfbeac4fa8ce178bb6396722757ca64078bedfacbe19196c4d01822fbb9bde", - "a07de02c6f311efd2263a3d4811c82803188bed8862a4737bc05b7f26a16f260", - "81f0f87a6256c05451e084c3f709340810d17caaf7fb6cd36313fb1ed602f743", - "8095e1850e05fadb235d822c4080ac9fae301e6e8db97e90326507ba0c6c6f9f", - "0634bf98d252deaa131ee7257fdc617abd085f7cd07836223c3d4930eb11b234", - "d962cef652c62d103333c9a7d815650455ecc2bab1884fdf7b08b9f1c05ead19", - "f05ec64a06bb7b056f642059e1a5507fe03f7112f4522d3e4f9830c845bf2f3a", - "d9e2a7e4c1d4f7dd03ee56fd18f256563353f6869bfeaf11070b598ce781d50a", - "57da2310d3775f3acd6163081bd895e09a299fe891912b5313a31264414b55ad", - "95c04141c02984b7bc228031e068f161595f29f819088868f93c14f170a51851", - "36de47f5120d600b1b32976541d65f4db0e81b9f975e3bc42f6f422d6904bc98", - "1866813193c7be7373f83ddfcb6eba870be7554aeadb1bd0c64dea40fd2552eb", - "bfbcf17891de1df3f5fa1063c2089adb9b3ac1c562676eb9b4dfec29da3f8a72", - "5733f642fd9e44c524fa900700f88eeca13b7caa00994093e2a55b3f6c6a75f3", - "e66eff93e64420df0d07cc8e9f207289aaabaee4983cfd79899a6eb065ef43f8", - "5319c208eb233b45e5140d3e8257dee06e8b8c14157671a68e4829489b5ba4c6", - "ff0f858c144df1b4b11869c9acec603493fae1dfb56f86d12d18bcbbea3d5579", - "e47351bd50933887cb46b0127330c5c54c3acfa4295633dd2a2c1563b899f7e8", - "c2619d1a6158dd2aee39cc925d76061dec143c3e97ebfd8661b8ffae3707b65d", - "25983ade35c008c152e4548b7d9c1033de0d17f785d0965992a425a23b1b2bfd", - "d74bff083b3fb95080dc07125f16254c5908817cf6fddfa75d4ec536aceb2305", - "280513776e4c4f4f0d59a56fc3be698808fb104f31e4ef5a080b5368d95dda6f", - "e658f7ea4277deb6bc9c63676877b71da980ef2642c73da8c7ad09020ac6f744", - "5062f324942777a39448555557140af64bc9b5f7af4b085c4704950752eaa2aa", - "d5fcf711aec2a9ce3c6f5574d41720a4b4cf0a5ad3fb1333246fc95f003798d2", - "8b4f172cf8d5666b19fe1c856be233022c88915bbd1b3bf0691cadc12104ade0", - "e10a491f66083bf6c6f86a8582acf6f360b7c3c65d98cc094eecc298bed9d1d9", - "263e7834afec0470a2ec0261eab4b8ae89cef629ea819cee957efbb15f70478f", - "0a5b7e3a85a3c15913a6df8d5fc5687de1228a1592989dcc8561497133457e0e", - "571211c30a253f11f72a96b5a5dd8a3a68c6c8b4a25c22e1e2913618722acaee", - "342ef75b6921246b95543304e05525d1397807eea862be1e64bcb26d6e3eef73", - "3b6f2d71284dabefe044ba5c6f2aecaea9ecfadccc42272a87e709f82e1aa907", - "93151ffe38aca1a7fb0ec2f7c193028be6d8b9d36f82ce3c014592112da22eef", - "91865fd101bb6c6748f59d147174e88e8c8ca6658b2d2bc1781c523e8e450c53", - "64b884c05044f57dbdae0aa692abcf5952651ad5547cdcbcde00f505a2892588", - "168f288f42350c63fe9ba1d5c91d58a7b2400a20f6f2efc7b20f0adf643035bc", - "96138c4385c5013d838018a22eec7e3a17ec3ad839cb81cfb5ccfac9e5e7e3db", - "2010b3449665a66d7f171eb3d0d41626926ffbbfefae7f9f1f0653d9270ad343", - "cb4b7ea83ac5b343cf963ab06db0ec37503c1322e89dbed48276c0ab905d5b71", - "27f613bddfd8d8d515233dea7824317962acfa9be51a3adfd8e32f3168d8575c", - "118699de932eb88cf717ff90a676c05fbf18fac0cf4bd23a2d8e9d246b2bd7d5", - "777ba4f7a9d3e27a22bffd414a79093b9312f018f987a72dde30757e8eedee9f", - "d95d09bbc359cf61c8525144c6d13ff698adefc1969c5c5b52773a1986b787f7", - "3988b12eb72dbaa615f69c32d1597001348dcc79d2ec41db761f071bb0552fb9", - "c66535864c5570d7da2c9079d2e51c9eda4aaae43a01068c2823737e650bb666", - "9a16b79beabdfc1a7906d7473eae113b16c9835be9bf86c50c5b26ad20b30dec", - "ed76da345e5a032b928f7a16b91d7380e2315f64f6db1e46d7601f5158cc3e0d", - "e7f954e327425bd61a840eaa28d583ea180185a3da4a63ec59ae3afe08c11a1b", - "2fa621832477722aa44d26ead75f918d1780886a10dc86027c6d1cc0fdaba7a8", - "790f099b7ff9d8b6d4838a4493f54721f4864e1fe3e348aa1738a6e20f69c55a", - "b560a84edfd39aab60f3ab7f27f88e327e930f345bae9604d4e4f9aa80a8908d", - "63f0c4ed35c69eb5df1471ed0411ee23d9aba94bfbb0b95c55996b908fd89dd3", - "47d27172e1f24118feda08f2c7e9a03660036672de46bc530c28afb94ab32d31", - "7aab9e4a21feb110526423d64285ad8001643949f444caa61800e19ebda60e34", - "daa0d0288ff6326884056fcfb236eab32757eadeb046bdc7249cda5080a1a260", - "5d8f13bf91ef242417ef58ba7a1706537e4d365e209b7e33f8e0444f01f5e974", - "f1a95330d4d4cc4611c0b022c58870c99dab007950f1c57ded207990cf15f65f", - "011aa8737de808f5bac84210e2399ff0e514809b05892b6aaa1f42f44f65bd6f", - "297605eabdf1fd9e7765f6f6fcd17adfe01741cf2eefa43e561fc5f2d3885692", - "3790ee028475cf56e171b8f44bcafaa45aeebf57e97a6a96ca054a36d3ae589d", - "1eac9daf10171d4b3888c62fd24fc019f5b25330d2e6b712bf53ac86724b2f91", - "34e31a672ecf1a72b6022cc0cfbf381fb424654be9381db647a1da6a68eade9a", - "a23afad315292527eaa64530b1b8157d54fa2f262f94ee12b6c00ba06d9f5a2a", - "4d887e1d189104e4c9e3cf9c0d3927e3fb10845cf76061666eb67f308606e843", - "b4eadeb20015add0d3aebc827e1dc23e0ec33a2619ca0cba9244713e575eecf2", - "60f8afebcdf206d944385067351ef06d6e15cf41779f5f0227435dbae747204d", - "0ca7a0f561efd54c8c795b3e37c3dafec5406145ebfb12bebee81a4cafe9d86e", - "12868c14551b4715eab774b115e74e31d80d0f530e5133efc5f01af8878a0513", - "6f67cd92f71fd830e3c8e491d2eb676faaaab464825f730da8a357d2bd8cb12b", - "b36e0facdace7c06183001879e96288073c9db8357bc983591610365f116d0b2", - "8df71693d5bfa9834d8530f11249a50ed3fcfb5b3d8797c51609e6b58f19c80d", - "293ff029c7e90d751f4b9be7b7cb689d345286b7aff253952971d70dd4b32d4c", - "b084171a098a7c2382bb14845a7f94ceeacfd680bde8a352d3926004f226f0a6", - "6bbf21e4f0e2c681313705b1668b8a381dcc5b5f7933a9840e80a01a3da534d2", - "aca55dc3063ae77a6ba2a2dec664557178b189fff6d96c502b91541280c908d7", - "97513ea699704f42e5ad856e541171e64ec4c26315d149202c4bae75957b6d8c", - "a5f21c50bc8a5a5e7fbed9bec7609b4ea221e3c18a9beb83b70d47fdf32c2411", - "478312f8b1d7018e5bd68cf01165349357c4664f6fe94e76ed5c7e0111bd1696", - "f6bd8dcac9d1048a9e9b03efa52056ab88712fda6baf14237b24e49ad33d7605", - "31d5ebff0bd1438a6afe86b08b3122e3a6cfbae703c4acc6a29554f9cd3150ed", - "b933acb4297e84dcd54c05dbde673db06e4882ad721c001c2d07a4e2cd37b035", - "0208a9b562edd52bd944a6a9b025364ccf1b41796cf05c34e0d975f460925cbd", - "e47f70dab31bb7422a89afd4fa2d13681d9cfcfb84cc8aab9ae5e3ca9a7f1276", - "98b4b805aaa139c3431946fb537753e863de771b54bbf767a3702249d0bf5897", - "e0575a2b8d5204ff3747e0de246f6aa9a004e078c1f6af07f80a0c6aaf517908", - "3e07a21c21bef027bbab4c076716293f87df01f2d2a747eec40b35207c866460", - "5a95b7e977f91c485ee51461a48c185e7b76e0d0df0d25910eb662d3e9489d62", - "24595b086ed0f45c06d8f55622c50b6f0933b831634118193d5db1e12bf970b4", - "4f4538b08d7cff2998d0686a32a560c2f3c11a3be0dec4473b72263e2891381f", - "f55bde7302beab980691a38cf3a9b638525ddc7ea812eb02f794c5e564dada61", - "29e364257b782e9773b548377466294c927cc17a91797d445fa5066eff308886", - "1cca1ece44316661c04fea5289674318b57d808c2fe25f23a3818a4186ece2b3", - "bd186a4ea44074a1d305b496e748ad7810a0c2baa296a073906eaf3cbc8364e4", - "b34e9674934379e1d0cf25141a9c1090eee1b0ca513fd377a4513990b8fcf2e4", - "9212baa96ecc66d190d64199e726a05398dea1595f682db3519602f175139ffc", - "aecb07c858c5caa26c38b2da57ae100ba08fa1657e467463e8514de8f022aec3", - "1728eb38aa83f46e9a6c3b2e619309211b8cfc2488af2c1ed737471f186718fd", - "cb83295f83d10bfb32de97d87fbbb53b765fc73ef8b3a8f5ae038821157f00ec", - "5706f9cd9ae05eef5b7595fb2a4cdbb344b4ef81c446f60b19a009d15cf2f253", - "be532b387354a9987648191e47ceb05c94fa917d0440339487492555b6144fd8", - "71aac3d66dcb54d0bd9c82215ccc112e2f1ef6fec07ec7c8245ad3f5bb158b12", - "f5560c2c0331c53319bac9e46c14ac5edd521a5b9961d0e7d16fb9250a8430b9", - "ecaa3dfc4c7224b387db7f9f9ad7e3037afee9ac6e4f39283ef43ad8c65cc767", - "6aae729e507afad23830e39d8d1f1f2be3da90314e421ac3dd23df4a42c0b664", - "09c04e66f4a456d7317940be5730f85ea26c05584f23b6506867d7007d4ccf6f", - "6b06f65416e7775f5cf8406820d73b519b18192b298220c3d147ae3959518e96", - "316a66ba576d6a8e2e17b4f9682c5d5ec801abdebb5e148a5e775e8cb3df9ff6", - "55b0a2c2ee8fc7edd6704c987eb6d057735f6efdce9a3d787687b411a759a674", - "d6f559597cbb4f3bc5ea3a2a27b3d954e1109b9fc62bce27410021a4345bea0a", - "78750dc3ec1f878b97a9ae6888c457fe98ad2a82c200975f71c3924ab4b654e3", - "39040ca8d3cee9d67605ae9e39dfd0423f3faae229071158f8ee3af064517ccd", - "c8c32191233b5453ab906450ca565345380a60753d7abbddd49e506b82593d4e", - "060ae662625a7a4e02d83aa78dc6086a7b5577356e47ea7fbb9bf36d8d761619", - "7a9c6b6e07a8b0bb5293fc622b4facc2bcbe8665c1cda6845740377f9b440ed6", - "260e6d9a6e7d3dd1cc48a54e50f6f1dcab91761c0b0b41eab781135d6f484f81", - "b20bd44c78944814ba32ebe1adab5610fd319816cc1fbb86f23982b10b8af45a", - "d99303da4a5064aae6ffabcc8f0513515879c7b4680b2df3862249966bf26f2c", - "ce71facbc3c8325aa86b0ab6aaef2117facaa9a3e67fefaa081b4a74b5b227eb", - "e6a17f1488000fcb262e1e7def76e93e8d303d2af1097904c5a32e37d7d9b7af", - "67b5a3fac82ca750e6cbd5faae1da5b86e243a8768163b20ff3d8daddce089ec", - "234712b4c9490125d83e14bf1deee10183fd227818bd4cccb44baed6ace16e7b", - "3387bffb6434585345dee9729a79682f6073f993f5ddefdf742310b207d1076f", - "56c8f56718049aab3868a8157c2164d140dd46e1fe61bce13a8af83b3a60c966", - "2868767a532c213335603219dcd15f8694b8606c121c56e60b3e582ea53ef542", - "ea56edfaa2622239915e7ccf3a0070843ca94a9d2fcd2fc539e383b03835a5c2", - "5c316bfbe1c2b569ff37cb76a6d00c585b013451f46fb81593dfd644b50a9fd1", - "b0c17ca904dc8cf7876630c8f84f0e6b5999058b0a679a5ee9dcc4c25e6b94f3", - "c049557faf6d56fc9187c04676003ac1a66fc0e304c096f4ea203d3388463977", - "8cbb2ea37095872d65ea7c91c45710f5fba532797b1547ed5d9ec4793c55b5e8", - "5102cb40f9374444aa34703704ba84a700142c24ddc97eb01ecb7a85e2ab380b", - "3bb05a4ab93e3f122784a8e41b8d1eb8dfcd69f05f65ec9a0493cf4cd99be620", - "94181f69ff4f52329a9bf61a41faf2a16a844ea3465dd54f2510127ce9ca4778", - "e75bb32b461e12c8b3cf4d5c4414f5d6cabdc3fad9dfdaee87dd653b66a8b75f", - "08f5182dca39b4c671ce7f185d7483d9574ff01108b81efcbf4421908758973a", - "1f73a20254759d8b39141dc7bff3b96ee338281412b330ee0f579683ca0bfe6a", - "c38eaf467f3c954dd13140718ccfb1075a477a49500ff7bb141f1fd4f2b3870a", - "5ccda4ce8e40642ca7ff80fc014f18bb092b3890fe35a6722dc33c7b3a213951", - "4ba13937b9bd1cb19dd698e5e3832e4a0084681a816268e5d730fc22656d0233", - "13e95db4cdafb30237f056e4b9de4ab97ceb3da5a574370cd5144f008ee96d81", - "11742ad1fed81f1d1c900e7ccd805858019a85d95e2ced393699c178046e1156", - "f7979ecae51fc39fc18e623ef3a23df7a95829c835c1f260878e2b5947001efc", - "b25fa675cfc7081217e0177c33db339aa06a03b8239cee55ca2e5e477920d3dc", - "2b7a0da43d5e3f12129d4ea6df3e9d0a825bef41958159ec0180d51110198f49", - "ceb6122abd1bf7539280772e4b005a82cb7e4ffdf26e57f868bfce5b93a1d2e1", - "b6ab0925d422d5c90d690364e88346f08dbfbb251b0dd5f0ddb5565f822ca901", - "a7c317cbdc90785094ad41096ad6fe740e88d53c100ed42478d34d995924fe36", - "9bb44d58dce490a3e694f8f34a423068b3806a3ce1acbb4c835e3b8c2750c0c1", - "bf96579fcdd22c366ce377bff7d2a668834ff686b32c1ced4d6fa01cb0f70baf", - "281ab45739944651c3b828c6731384b907917f40e46e73e70935e449ee0cda11", - "adfd5d1c1ec5f8e94f982f73d2671c57bc75a62236f50be4e5176dd3ab488cb5", - "cad5c72e6ff149c6a8a57477c0e96d85eb761488bbc82d64bb12224e4af00a08", - "1abab09f6c76b5e63725463bc1ee86cffa070e12d7f654f4a764e134c236deda", - "b0e119789ab6c3d7c85bcc3fa9e78dc5d92cf8c4c84662c373d6db3e966c84c8", - "d3bde45cbedaaf35748160fb4ca91a80f2bf9601ecc35f4e2830a90e0bea15ec", - "74dc67b7999c3795bd5abcf463fb0c3e630a3fae3f27eab8b1473da6c2a46423", - "b0056edb24f48a1b58f93fe04536ca8f6674d249bdfafc57f55df70fc9c08962", - "2778f5f2ec6bf2c9f2b346842d9eadfca9d41d93353017eb66b1b2aeb5ea7a91", - "7061c16e14534d874a2eb1ff019a07db9f66eea82fa436b7beb93436fee1ebf1", - "28c6efa09a5a52a0a279c374c4e563d1976b03685c672685d914d15d72721662", - "bedacdca3a597fb6b9be70ff3835d4f7965d7bae2c71eff3516952562fbc28ed", - "6297d9a5d6ca25b653b97c9d4fba56b454c52e42c221e668ee65be5ca3b2117d", - "03b25cfea78dc4b15c7449ce2450b70da4fefe1f0658ad31074aab2eb537d34b", - "8dba58f88e07a6ad60c56e7fd6dc5a3b5133ed19374bfec95f990b7893088bb7", - "d90a90aee45e829db884f2d80c08e0554d616eb0259a567a00bbea717c0676e2", - "d8e7de5a7f62c73eabaf6d2efa92d74867b21d277055708262be8d48ac5b3f7c", - "7c8808793e75f830b846be6f7883f8130023848faa3f49aa5cbdb429cc5b206b", - "3af9fedd03a7116f06cc73f4f8f1eff69f77494e9f61459cf011a3ecb9f2659e", - "05771b2b077d877833ed5f1c71c209e96bcb413cfbb4f79908a4768e787f074a", - "8742814461f8b193fe2c7211f866e16ab824b808eda1b4e51d04cf9beb23dd91", - "1347feaaeb576c580c402e61b71e71c047217b5de143a8f63cf049a31a253b9e", - "bf6885b66eddafec93f1f3e201cc457ce51ff32710fcd573d4c28db117f38008", - "fac460a8e51a6ff7d7303b291d9c6a1a09feee43d7c28629807bc210202e2a0f", - "8a8463a5eb6440f1305aa7a98dcd87242c0d6c9d92b3dba815a6c2105ae94b4f", - "fbe6adbb981cce94ba858eda47af6f329082ef6add007c6ba04881c3f546ec76", - "373f8163668237a8717dff9367d152884bfc33e7b96db471c0c3bf370dab21c7", - "3a0d18ea5d580baa74a70446f87253f983dd95ac3a77dd61113a3206214cce2e", - "f291af29d92189e130d7151f4f05952df40e17ef29e2dfbf29d491d03e259116", - "d41abbf119271d2fc834119d2e2e5cb2fc596eb2eb3f128fc14918b9aca99d37", - "0cbb887fd49d226b0635a20525d18bdeff7c92e497c6d3c8ad83d988c7f7bf7f", - "3b1eb972059ca6ed73374f59542ff973d61d945a41f2cee1f5c67fd885241403", - "b5b38be9fd172d7995e986a7392b80847249bbc8c72ebb407cbe330dcc02a45b", - "badf5a1699ab37df0638b9fb0eaebdea965e4801027c6c4dcf9c53bd70b9293c", - "9d8227d645cb715e30201815c9c1363d0aba2229648f921621b4117964aab1dc", - "3426f186fbf45a82cf3f11de75ccf7fdb7c67bd992670c120041e0e502de573e", - "d2cb3a225d233c980c6d0d9a7bfac58b2d4cea3180405b5d0d9bbeb71eb8faed", - "5432f79575fa0e3efa0e97b54253ad8be29835564731da84b22afcc16b2582be", - "a36abe0f7c41064fa4600e29156a72f5c8f2c7a6b4e254df4361d52b8cbca949", - "058083773dbb0449d254d614e11c7aebcfd83bd22806d8f169da3e61cb9475ed", - "357ffd0cbb2880b88d0d55f9e15e8ba8a3dc5b1b10cc7bbd5e2c2ec7166665da", - "a308303fbda6f8b4edddc07c687e83b426ce0e6a5a477a3563bc3f8b5ffbfc03", - "b529ffd26abee3037e117121c04f4167f6bb00de259c2cdaeff279a74715599e", - "ef264c4f48ce8c5f470d68624758ba456ac3ccd335f97ab8dde399375987fbd9", - "66c86b11eb03f7209f9ace371210ce6244e9e1343a529e114470114584465907", - "1d593eb86915acc71784a82ed639ab37e96d6c589c7419677369559fc75d116b", - "6c9427eb5cda9951ad207711b9704ab899f56d8067c10eed0b5bca9fb04cd201", - "df384a0b0837a0e122b804d9b77e0180ff0bb48ca2314a33e8b09970b1d0f9c4", - "470dc62696126e8d66794395d97a28503bb15c12a4daa5cf10ceb87bc7490175", - "0e95ececfee017c6960dc606e91be1b5a3b7da99c6b80bedc5224cd26b7ffcec", - "0002d4001194800888eb184fdc500b994e37ff01e7893f2cec985d915e69f4da", - "31b2c6ed2cf437a8a8725940b3d5eee321f466fe169c837f446ffd2c4bfd7acc", - "d4d475d390e9cf2781fc406d8764092b37228d3f84ffe925dc6836b34849ce0c", - "459e515d59722bb95b82fa1bc2d859deef4d53545597dcf5f22f59810d5f073c", - "6138c6cdfde116c962df4aecd0629cc795f0f5898f740e272ed01777a4d9d35e", - "8cf8cb4676c0ba53b5ef99fce9a157016a8889b9ffd29cfa45a849a4a04c680a", - "98850f2c66d80144448a01d9194075ede7745adbe0048b9b00703c7bfa32a447", - "da868468d0c57e50fd9374428cd012a92f3f1146dc01a220e43ae3725c3eca6a", - "deb3e31cfc8f0b2e5ca93abd131a6e4a40c45ee9525b4c9c77cc92160598329d", - "e6a61c20fda8a0f1a4eb096034aed5057d2ab5e0e96ae9880335bc97550e919c", - "f611f93c718d272cd378072a6f024dfae00553d74bf76bfbb4c75eb0305c7315", - "469934e53684de5f7331eab064bb981ef63f31a83c1c71b5fdf12edb7c75b509", - "0753480b1d429307b5f34ffb8f5820d1c985fb9e59ff46c582978d9f0816230f", - "136f87eb5785550ae86cd350224db409e974e70d2d4165e5266838258bed70ee", - "4426bb8235f4648b5b6a47a87dc0e45800391fad581c3f351c4f101333c69f58", - "0485b080bc2fbe59011e814fa26af2edc0650791471541edae22cc76a2d4a7f2", - "cd9e89931dfd410ffd11dfa84e6dc9b49bfb2f3c79f71f39baed7449a18e36ff", - "45ac2dc8fdfaded14123cca97c260dd7e8f2300ef7cde017bf41f0960b8ef44a", - "5081948138d02afb27a76b1d632ea80acae9b4b4b484ae39f508e138546f8d31", - "0d26a22bebba6d9944bdccb8872b9656f180f11b7c581cd48dda998b417cdef8", - "5084e640ba745c7a92fd2099477a7fdac5fee1dcbd6f2ccc4f37fde576447c65", - "8d85217884967ab550aee0cb8ecd60da69f6683c230bc6236b2a5c5a535c7b80", - "1f0ec3442265acc3ec6729c0479089930f9650580cc7ac7f5bbf19ea202c427d", - "17546367742e9a3197b04bacc995d327f91c759078ff5ec5c67027fc24e7242f", - "d3bbd33dcf31fe7988533fff39b8e4e5ee4891202e75f0d3d84450c1a0a762e9", - "adfe9ba9b10ca2316ae77542ddb8cc47c1273c53bed7ea06c72421dfa0c42845", - "b28f4526431d061091033a86c29a0714b33532ea6a9179d208e47aa41c5f2336", - "b5f8f44247f567b0fd4d6fed845b25516eb0bccdfde1936c6f610ebbbc151527", - "f5c2a2263ae2d1ae6b538aaca1f709e398872df4ddf32bfbe803dbb1325d2f26", - "c977eadb684550abfd013b22e14df90a6ff746b84f9e88f6324a3899d5f47926", - "978f1a493dd975343aefb6234291b9811a8fb45c5e4754fc11ddf1815f82681e", - "46cdc796574dc8cd59ddde6808e08a44f559fffa2d9ba917335dfe594a1718c1", - "9a4275929cd8db7dac055a7afd08fe46725a12ff11c3be1e8279b76efd2e987e", - "89bc193c2ac61d1c980e68038ed1f355f8a60a9baad145901a2f3c0436db19e9", - "f5ccb8ad581a0aab43d092f4b3909fc641486a2c3d0af7141f57eed2cea54179", - "ebd811cae9e2269c9ea337c80a300c9923906486c31b2505016dfa77dc2fe91e", - "76b334370abbb47ab92990704c28a9add8881f9b9284b78ca459b7f2b3773e5b", - "1742426ba2cd5edd1643ceb164fd808dd7e0b66296b7609b158c9662e1a28f0e", - "4fde356e78564580af248a8a9943938e96f7c6730c26169b14c6a3720aef417f", - "99678a8ca156fd84093c900d1671cdf7706313ee86c7f8a4e85c61fe45f2cfd2", - "a4ab9d4088d81c1e5b23e47aa71f7d4d3fd495a10c148de3c0c3c09e92133050", - "11ad87238467344f2fc876fc038f712f65553ce7cbf773d64612f9eda4c8dc4f", - "b25565dd1fc1202c40fca4a76bbb3ea41dc97375d3816eaa13a44922c9df0cc9", - "b3b5fb20a5872c06fa163b3c1f3ae1624d57d58b83824f4b9660c44fe7d61b5a", - "7d7bf936b7e2d595285dbca4789359bb5d7e5ca59d139c9942428fe0cf5d2563", - "fabf4b34dbfb1128d5264b918df220d9f888cddfdb2d2c1347c921dc549f0d25", - "965cf0c2509de710183dc6e794c3e741b19cc2b1657dcbe3a4e3137101189e00", - "116bbc8102e1b767bbadb104e64d8bcbd51a2b22238b4f81e69ccc9208371dd4", - "ce954f994201303570385f473f0e240e795da04e8fbfbe1ea3e231b06568fd20", - "b32350e014a72aeb38cab5fb2e649809449b58eb9bc3f5503af22a1af6c6e5d9", - "0cd43bbbe76a4ad3947ae10e24b2ac391e55cda8443353a3319bc0cd4a6d70ae", - "57db68a4933fd0838d358eca34b7677583340cb99d2c684893ea98d37a256381", - "f8b600679410237825b73462997896bb134f72a0bd2649ee3f61f34248c175b4", - "3c1b5d39f9d23669744155753b7213d6d24d191c68600daf2bc1e50c0d623092", - "33be59a820da4802b506b893a966339d9ffbca5ef842c6b4fb0e9891aadd02cb", - "1ad22ee8f9b416951f0b8feab32c0719d5432023f615c9156aeb006dcb7276ac", - "9fe8c31d237b968e788d3fe9b60224c7dc015adbb48f5cfafdcc4c2d06440a25", - "e68eb08c50b903118f8d4d2dbef29845ff3ad9eaf5d1a1f5c1b04b28df8cee8f", - "390a2cf3ea098d2851aeb9742d2b270c613b8743034f9d5fb58a424b5bf46138", - "e4c616127dcb78ebc6e7b84fb9d8e8493f6bc199df957c8d3a81cc47c04ba2e2", - "e0fb3cde11cf12d5eca02cfb5b2422292fb5df30831f332fc06160717184bff7", - "499fa5e1b69a54c3a307bf080bf0d757b8b3762fe00b69084b67fbe5f755bebf", - "2de2841df5d490ef76908f9e2dd9f122db3df1e75282b2fc96171388469db73f", - "cb23c39d5ac681d239d4a6e97a31b479b9dac2af40cfe3a2874d3d42bca94477", - "48d93143f1da4f69b5066827f35f924c10de9784877c183e0e2fd9069f7d5edb", - "91e56d1706df065b777b6f8210f5e995cd5c0a913a94142bb80ece1e157497cb", - "6ec1b4f0ae89f3af94732175207775963a6400c138b423474273124bd6df62a2", - "6d9deecc92b34c1dc995eafecfc82408d9e321cd88525b0555aeb0590da9c957", - "394ece05b2c113295177d14dff85a805fc94e272ebbd166eb1cc1ba658a4dd21", - "1e3f8d372a179ddceeda09165d917bb0093ff707a937ebb23c24b0e712bd06aa", - "4cc054a27074e5810f31a96f20b2427e39c7eeaee82043258ceeff967d35d620", - "9d48a79edc7749d6afaeafdd86c87642628b663dae740dfa15ad7f8e3813f179", - "b03c9eaea719e03dc0d800089cbbb1b56f3891e03404a937988dee22949cea19", - "eb2a0daa8adcc27d223764295490a824095f19ee3683c413638f45321d561b99", - "1cdc44f83ac1b589a17e745ac1de372aeb0a73784efc9b7a4f13bbd0fff13053", - "203f4d9756ea48322f59dd6bd5d273712240265967d72b5d4b2b58ddf18aab3e", - "9db89903650b66c9fe226ec9481dd0817b7437d8bdff4168cbb6b539ea1056fc", - "f20f1f1eef369b10be29ee22a5fb8ec3b05158070c6cc6d7f90e33332f10384d", - "ff78df562cc48964a52f6c055f8e7fdc82eb8f610d18c9d2980787f93cb19225", - "df4477d7fd01687d3a094f441e6a2f42d71fc32b2c6303c7a54254e5e4711fe9", - "34a0d35f0fd69bf26f273b92ef6593a8352760564f517329271fd70611cbdf8f", - "6ffba2191c7cdbf91c88a634a320246ee4f9fe22c6b1a8fa33e44e4029201a40", - "a0ce46f14db8e92763023e7d0a345a88aceccecd8f0f209d6347c70664d2e026", - "ce2218aa795aabead71c4274127953f050eab14237d22ef6c0a2f55695490967", - "668cbeaa83ac432afce23d8e772496533ef46b774916c05b5247a9c08fbee53a", - "2480fedff03a0d0ee3e4e0161853d93454704a817496c68f3b709a8b199f446f", - "51250e36434d84569a5cf66bd361a2cbf7badcd3b4d0157d8210fc8b7d745f55", - "d1833b8620fa47b36a48fbf081e83c614dc6b7c096aa05ba99f95cfc591c6b9e", - "a302d5369e711f3d01f8dcf9579e4d61322bc91c8068e070816cd71fdb22dd66", - "a1fcd0f021761a3671ff0b8f9dc8d2f80c978665477f5e5fa3f0ef908e5e37e8", - "f5fa8390888b32e1d24f03e3dc7f8f8603585562f48584f29dd26a8f1f3bdef7", - "1acf7d9a17b795e6b7a5f8f5650fab9e10a561b4fc15de738cdf4707742ffdfc", - "bc1af418b0569d4b7aba109fe7a44dcadc969c2516d48500e0d3575b85275aa2", - "6baf693288973f5e331df00ee426ad85b6e8b89f23794d367974e673130264b4", - "93c2c3bb8f3aedbd8f240150d7524ac96fd69aa52ba0d88ab5e1b4cb23efc542", - "e35286d32805beb0935408e1afcc42a3ad3096148767e649e28073319c07d949", - "a4d70a8a3bc7a6cb0de6a91bfe0dce4515c83ad8c7942bc60aed00713fc97283", - "d41ad0ea2e560de3fc83163811273078558906eba7398eaa07b00bfd7369039b", - "a97e3c44931f3ba8ff14667d9a335e2edb48b292720e781a31225361d1195f26", - "3272576f410c455cda0a3832e42e06e4432e840c7900c5a3ac4ffbdb4fdbdb91", - "c22071d7c678dd65be118d959f11e4104f59d4a0b435a0eb83558522c7fdaab0", - "f9c5e093670ff47de0d0dd7fa6aabd7a151cc523969e5e31621d710eb2224ccb", - "7a8bbcece0509c71691af836db47ffe05cf2e8330a0f8be8d317c5abc2580af2", - "ed3b4f56797565b1676f8cad4813b77e4f55a7733912fdb92413c7a7dde461aa", - "ac92a234051545750e7e5af8a07e694243c4537a597eca0d86cbc1f6e618b8c4", - "767748de6ada4ba09988e748ca217560781e16d7ddf0d33e0d2cfba986de94a0", - "5805ebcce84c99a0b38f59c24e711f80104e0607bfc8fff8b46c19c5cc0506a1", - "5ecac6268f2dc0b793e559aa75c644fdf9b966360bd2d2ed86b872bc0fa1b606", - "2e80172769c7d5234056b50e5f1bd991c970a5096b1c61ee78850f321f277e6c", - "20f7750fb60d12d2cc64ea21861858abeaebf31424598e34ca2c412a7ea41fa4", - "8a13f40fced2695a442e6e957feac347a701ed443b973a7f7f8fbaf3146c9dc3", - "84ef6333b5cb9537c7a47e2fe9b16d77a9f847f67a76e01713ea91bcd8bc0c25", - "0952a994178d861e02b9db6dba7dae00c6159f681b5c48e7455b30fada4940a0", - "176c100a5dafde429a68d0ea0eb5e5d9cc044a2f56abb38921be0e0d0ac61e55", - "82cb0aad73058b7a201688f4d9860e007aa7a856e93364764abc437b46907ac6", - "53bb4045b0d23925f21291cb65144fac8e6c3f0cf64b69a84a5da98039f0a5a1", - "809d81212bca8562b19da4f8267dcaed1bfb697ed9c4231f44958f616242e859", - "52f378cd0f8785398ccd80ab42b95a549bbd94c9f1cf5ef05188fad564657895", - "a111e8df0575df0e50ba1fdf21b8c7b86e849c43c59bac963854694977c83f72", - "7ab65ddf82315d5510dcd80978f113a768ad36edd6c21892653b5f12e2865cf8", - "82a3f1de676ddbaeeb43452134061758bc1a1aebaceec41959831d3a6de32b46", - "aa8612a3cbd9dcb44eaf092a265f9e00bb95c5203bd9b19ee28f97a0473bffe1", - "7294764e301d60f70497fe67d534427c580b70b4c10d73127d5f525a6a0c69cc", - "7ad8c342c59acffed9834026c943624d26f2e40664898967b60184a8152e57a0", - "99ed0cc33d4c895f45a2c256b9419ad92073da971f7af2866e5a1ccf76c80348", - "9f0087e78a708766e464a82c5b286e697f6bedc7b01f1fe585efd1419ea8b429", - "c71b599b6e830f8f4e70428b4bf3215bd704d51f438f12ab6f70b164b16df468", - "380024224adc8067c0599c09a0d7555070874fac4c67088e84ed2eb2ee25459c", - "e8e3c23cab8770fec8e572e36d6f364e7a0147c1020738ea1087aba06f8c10de", - "f9e2881615fb9c75149bb1475e04b6f715b753157a11d80c6a73697b356d2d8a", - "7c806a50f5f9759dc43ebcd8a3cff3301b9d68e97acb90577c2cefd4c0fad5e0", - "ca5d8af518f7605b5528def6f6ad13a89d2053cf1e8c1205f439a41f8a6fcf88", - "3b020f5821b8ac5e78c0cc055d3e3e017bfa1d68a15b4f08a74efa45c7e2d689", - "13c41ff9e4f479fb7c99bc91c3d61a530d60c0ddef0fae85f36400ffc0b91b73", - "ed51b7efc0e0a9878f90c1ed98c3b217e285f7b0611b8d690b553d94d3e5ee6d", - "6363ed68145102dbec3ac3f91b8929e8dc0f2217a0879cae6b3e6ad114ebb704", - "347333225bd9ab00617423610652e91abf920f033a3d7afe96bd7c11ca317997", - "95872766b040b1b874c3132fedc15343a81c67d40dc4f4da0289dd03b8bcda74", - "870bc53254606809ba373907ea479b690e4baa40df122f141ef85831acca30cc", - "7146eb8519311c7837b5733d8d753412adaf70d27dbeb21d1436219cb74665ec", - "bab925ca1a1f92e0d086631c5360913bd423ad98379aa0355156db661a77db7c", - "ea57c1cff0563d378275f272cee6e2df9d4170c2deaaee21dd2ece02005c2e22", - "94566a0c4e89094f6b8cd8a0b953ca2d4ea0e53947ba14b5a0fd954870ed92c6", - "b3551d214f6a1f6a3f2f2d8ce2616714147a8f32e6ceb5203ceae708bd64aa3e", - "588ac434758b863ea0168e22d9819de51eadeea66a18179910072457da215ae9", - "819e79374bb0da200a8ebc5b9190fde1384f8c33f8068b3c6510f7176d351899", - "78ce017741e6c106f52dd313193c1d2dac87358559bd716e7fee38c9bd8803a0", - "2e16bb1a9bf214b63372a1ba6fa5a502686a323a531fbd0d600d2a00a23d8ad3", - "44555683533e004a23364520d8ee6eabc15567ff18b5de8954a7f99a09c1b7ae", - "5dbfebb1f90a65e340cc7da485ec1f21f2bf478e1540e5328a3f6b9bf1c142ae", - "a324a79d58e406f477bfd4e8e7ec821644f21a01229ce1f9778aea19754d53ca", - "e766567f90d86822995c707c627594941462e2389338ec523ec913ff250d7206", - "f8655f40d4c147413b8f06e36b7c30651ed4c2e5a5307131e0f27155f5aeb256", - "44adde170c21fbf008a0c4c9ba491cad8431655f8d2f5087b76eb712a9b0eeec", - "113bba45f875ae2e47887ab561f548b676e989762ad8996d0b57d9a56427a79e", - "0be96f076786a1fa800fd7e29bc10abcedce57aa4e6ee0ab4aec89748c24a34e", - "2036e8c7b646aed16edc083be321a9146e94d82153c6023fa60d6ecf122e1405", - "c5577997249c406ea166b696657fa35e3abc4d566db69b187ca40f874602ea3c", - "d67352dbeeb847b6ef13e116dac0ef405b9bde53ee77171387a568ec0a9e4f4f", - "a017b033ad50d74e752e34a240dddaacbfb7cc5149477899af7470a1c00b3d05", - "bafe1029fe4e8dbcf70d2032c8b11ac2603c3648467dce4d92a34810d5b60beb", - "255db407d926ec049ce2a29cc34626438bb9c804fa4615a26474f0369771c2ce", - "100ebcd7563c54a810431535a2ea875f9688f2f28f8cd40182908490cf64b787", - "8942017884af5ec639e3fc7c53bc4564221e9c61e1c35cd79a71ec2e1f59e166", - "428f23cd8dfaccd17e40146ccc84f3aebeacca0e49064033bd868f41b02cb6e3", - "b599073ea9d6bf42e047f68c564f53b5095b4c02a20e695d6e7cfb286d576582", - "99470eaa64df50777224def633b658de6eeb72494d1898363dbdf5b16cf5a95c", - "9b597666f7e6ae3a90dfd434ea4b61247db90b6f91cd85424a083e7e357a4045", - "66a476291b8ce47b9a38558f0ef1143a4851983a752b1ee45d4e8941ad266f5c", - "5e44a712de961d5492ebac788a800858d0e0b8eea80eaeeece486292ce3ce43b", - "890964cf53eb6680e681ec3028a71be004e2d52e6fdd41b4c1900eaf9a3388f4", - "db117d1dea4d491bec0bd6c79c27b18b8db0e3bf61d69957606c3a9fe10d2409", - "1b04ce28f99a52093bdc56e0530fb523d3a04586e11c5d3555af8dc5e362a180", - "8a2056e3d55aa228306aba7f7365623b4fa9ff62133c0c57173d9c9678cb7b09", - "64fe9875ce4e1e4501f3dea3311b4eb68cbb30b8692a8452e1943a2ae73ddd78", - "17efde8d03801ef8ffadb997c5b7e671825a873fd69689d6130873888426f062", - "5de16be17149cc41bb534c67489ebd302b3df7531d52f9918d565ef80f14c852", - "5beea5c8b4439e0c6554269d527b6f2ff1ee89dfdf52d4ea99d153e78aa9f77f", - "d377a3ed06aa3dae9057a489aea63be5bdd380786881e4a0c1d7665c8eb57bf1", - "07a6b3b3727d5096b48094c1dbaa53e42fb50e85203eff475c4f4cfac8846959", - "5920b4f90c09718d7c9239430991cbdda4513fe52cdbe7ec620d13a8dc05b1ae", - "7f2a9703584311e039ed62900572060f8a2b2ad1936404db7caf3119146fb09b", - "8221c6eeff9d7fc412d25018e0fcd9be5d0859ef70dd391cd80afb582635c41b", - "a6aba9db96b1bb0ef9eaba122dc6822a693eeaa7b27441c9c722c7eefaa1a875", - "4cc845901b861886c204684d73700bd9bb7e1b0c96e93894ee9ad81bf0761cd2", - "820f0e7ca5f903c2a7cc4bbffcd83eac881fe61a5d9bb06c1bd354e97367c355", - "a7ac6342e919ca06e0dde8a0f43f8caf1893f24f356c8a97db7f866b6060ace6", - "81062f429065c752dfc1bca1009675b4c1858e18dc58296f2ba8b6b94ce1e53d", - "72a55d0ae222a67cfc65ff618adb4f69c81cdecf94938c3fa58fbde262b0b02f", - "b4b39a2eea4f48958c9e44a78e483633d8474367ca4a731cc05925e6ae25292d", - "98ed7e7cbe43eaf462b37274c8fe56f9d4c596965f704d23aca452ffa4a80945", - "a7a8a504b49737bde60de58e51f73a73fab33ee184ef8c138c3e5a560b707f21", - "3d34c5948da9c60065fb84ce84e307a64a869fec89bef0cf01ca8b0a58ebbd44", - "9c7a1b81162528c638e2d4e80edd314e70e369ff6a2dc73b75e8825bcd488678", - "49d1681c068d14eeb2f2bd562082447072c1e00fc63f2c9c9f0fbc4ab6cbe99e", - "1f13dc3456906390293ad719be3f5663831a315c3d3c12812f09b0c9d7084ecd", - "f94c1c99629223f72e46e154bb6a8dca579c285c583c67def9dbcccbbcf09c48", - "f2d100a36d8cb2a1f10b8b88ba9e392b3b6723910b7dba4311b08678eafbe3e1", - "631833c37fb6d08ba7104603b2ebad86b57966c3b460cdea11b2d1ed9f7da8a0", - "9c5c7f7987a680bac4cc22bfac3d4697f2e17fe5c36fb72bf7a4b642c06a5da3", - "dd410a14ac26b3266d153ee48cfc5a7950f22fed43db254fd0cca3f4f77e12c8", - "62ceb0c65fc10a74867d6cc7d3f36b2dd0812afd44dcba3d5c27703789310fc2", - "e855a5d43b5cd8413c2e1f939dd51d98e1d5037c0cdc47112a677a31c6474816", - "29f2cfce22c7a1507c96f79326e7da3aa6966b7b46139142e457381fb3ea56a9", - "86c72b790006f8d426c98d9120842b8fb53175ece170548246a278919342dd12", - "e7edc7b3f841fc11041748b5d2d32c8a5f39c0ba3386c3ab19d945e501a10491", - "c648b7607fca92c6197e1287c72829eba8942e490594dfcece8a8af96350e0ca", - "a4a89a2b3e1adb86868bff3c54f54907492a183576d3723f235f751d27c59dfd", - "c8e6a9a8deb4d34098f0193e779a441ec2a017fa8c4983aae8172512cb909017", - "e7ca2c7153a10847e81c0a6691a7760a45b77c5249743a6c6e959606110dc0ee", - "c7ef8f48a27eba687e9b5f525c2cc2149905bbc54b969bb8c9279da1ee03f086", - "0e963c818a936a330de46fa56284930a35a0519c6a564774ec0bc9e7964e8a1f", - "eb8f6b9eade33dd8eb4a6aa215371f1dd7891e95df94b974c697580aaac30eb6", - "2f8f8e64e4051a816728222f8b06c7540dda241ece8352fc7753d81e66bf0a6d", - "9e5fe172f3f6c99ff0fbb8c0b041a5f017daed461f71a43efee509098f7fc7c9", - "fda2ea0be01c8888e95174471efdde0c710fe1d24220450073c69173217f8dcd", - "17972ca1c9fab7af548921f7c36f3e19fb208ce26dde6697ec2db657b1f89aed", - "a4bcb1bdffde3680d58222b6ec03e08f5603dc80f3a67c324ea31a6b10a3b291", - "a83479180ee209cf58819b6d0a770c1944b5f4841490b609f6145e1ef366cb43", - "44efffb121df5ca74ce4782c984585f74699f1cb50f13ddece101482fa7800d2", - "ce49b3e65c0c59cd50331db28960a67a1eab218e4e218a02ef29a89141a19549", - "57d6f77adda021443b8254b4a1fc8a7539337ea526677367243abd1fa02d94e5", - "aa53f4b2ecb9bde8b990f6d7aea8066f14e351045899166d2e8fba3ecdb3e1cb", - "d8d65d511e4e34f193742e9fe0b148307dbd53dd069a684e7676fd3ecd6b436e", - "302cffdda582b90fd952edb762cf01197c31bc1f65767b0d0efb6f31b71eb779", - "4cbb861f52e287a71564d54e8adcd5ab138e37e88068ae6300299704957879ab", - "947c54661cd93bd50cce1ca04467027a6bac1a21793fbf31d1012e7338f1499f", - "fdaf112471555279c522c3a47df137812ef92dff74d82bbac596f8fd7fd6fd4f", - "01fad30060de492388e28ddc48cd71e485f7344118232f1d87b063ad96c35887", - "398b0cacc01367c7f614971ddd6cb463380f867eb98b7d6793e9b9b14e1d4f04", - "06b80277198bed1451b86016ec6e1519f5760a2184dcf63977af88c805ace80e", - "4e3b8c6d7fb3c93845762777260a03ab15f217a8cf24053865bafa1a6b7650a4", - "baa58ad4a496eb68c48dedae8785ea727923c61d3e3a593e816d26ff987f160d", - "79eba6996909b33c77f048ae21cbec92173c3be39f0084cef6e6f1d76815ca47", - "31ad147fba7762ad9758d0997d53e9d1d11c8539b88dcedb12940f6aa683b57b", - "20196a89198f98d877d2713da22f87191f432a2fb9cb90261d3a722e25e5f6e8", - "b374edabb54680272e0c878de9aaf1b3959431e8efa871c984c8c7648185d99d", - "30b39eb853e8cc1f9b5f7c2f1f51a0b215f775cbf27389504e5dd1b838ed51f2", - "d6b88d7fe596b679507a11f9e544b6a9cfbaf1f5b60184ffaa3e8a66f3b5791b", - "8381f04609fb3e80111e82b14f8477fc96b87d8b6bcc2013e50a7feb502e0aa4", - "157df9eaf17fbf22359c8283c336be0bed7acc98a776a4c48f639f135b98bf8a", - "a8d163444bedbb92c8a6373b7558bc6122cec699fa69deba12ae053e4ea91e6d", - "752104ec4870c52c1351be9506579481eb8f64b6c7d977a56e9bd0f394c141fb", - "d0a4e8c579b0e07ed73018b92f9f6686614b3ea100857a8598d19bfb1bd0948e", - "0b696e982b4bf41cdaddc5a6b79cc2a09efe927d9a2c27a20505d71709382f22", - "e048038413a0aae39a6ca1019acd72aee81f84d89d1dde4797c8416487597c8d", - "220d28fb0242dfa1af79be134537605cd89a921c880b6550c6623b0ccb37fc67", - "bfa5b660d66e66414c2bff8b37f7cd3a79bd2a798a0b7335b573c13267495dfd", - "a91c439b2460c3c4ae11405558d079ac507f41ce6f3aa2a09200ff7c8cefeef4", - "d5398986015d891027bd88db2840eac8c85c57420a0ce68c832039795140b0ea", - "534859fb7743de6d9d56ccf43d9f70cbf0cbf444b5b826d58f87323fc667fd40", - "189f8866dfe687e1ee84ca169e64e9ae49655aa6f00450517813c553a9c1afdf", - "b487c632124b65c8c5943627fbd9bc2f9b4aef95f1716248203e3f79fa42402b", - "3ed57a44073dc76f7b09d3453ae0e337f32d8f95f5903855a02458c72907a62f", - "14431ebf7d168f66371fdef198bf760a0461393fa7a93f3b3b892797cb3c21c5", - "8d955701688686de47e2f93adb346ac06e9b1d528af6dba983fcdb48e77309d9", - "a0c626be854e1979b3a8390dadabd2defff6ebe854b26978eecfcc15cb4d8176", - "cb65b5e21d52a4444717c6747dcc42eeebbd51efb4d83ceb5ce6439d0125b50e", - "960529edd9eae42e8fcb53fdfe056099e058ddd2abd5a4e5003c36df8fb68235", - "fbd8e9efd2cf1473bdd40c81581fbc49bae62adb99ea2e40f9dbc4fc43a096ef", - "3ea88151b5c0f3453324c4f2b065b80cf37ab25b3631d7f2e7e941d1531ffc07", - "f1a8420850684edaa3ae6bd0f6c898f005ab4a0920233ddebf15c90110be8ea6", - "38877125189dd5876761a2359444bffbc035fb680a4113db90e37a1b28313eb9", - "b1a134400ca28d0e00e65b5a31312f4a0c337a74000a52f26d5cb231e32e88d8", - "4278158fbd27819bcb52071c2a1579eb0bbc295019c8c3239c8e6ce9efd94b22", - "982206f8f59eefe774c6fb67fb63cb663f6b3b6481c208b71eae6f508fa6aec3", - "0b3c8a0b86c64aa02a817b403d9f4b93f57a408df1cc593775823e4fbc93328a", - "c2b02d30c3ea352fab3371fd4bf6b8e63b76a42fcd1b61270e3e195a3b068e29", - "07bd1ec4fd159b326a221337dcb5ba7d7bf9e3b24ed6f540d25b79d30335826b", - "231008d2b0ee2447f6e49802dfac20694b5e1508677968a325953cee977c75c6", - "3037c02fa7504fec92e42fc5cb9885913ac331f345a56e030d81f0add7f714a0", - "0377ab255464691c2a230ae238fac48450460c27ac4ef8499107184324bc8eed", - "7c32e51761f4cb5eed9820886575b848c52b692fcc2e257e9fe8b06ab1edff3f", - "be8504c84c65baf8a3c6c52165de33a7ed41a718552da7cf5cbf83854225d5a5", - "951c1723da906359d237787f993a6b66f2cbf88bc14e052bc264d90751860c23", - "6ccc0bf109a7cc599659ab1196fae2c93569e63241b6a163058690f03ba92f21", - "bedd5372a48f2012d377c91c068d95f73168d0d2f2e11696bfea19016c50aad8", - "cb94b2deaf3cfa01bc33c76da5e3f69ef67d84da0d200ff49215c8d4cc7ac3f0", - "485c4e86e1880ef61ec159ed510c8a2b8b11cd7574ceb8797cf88cbaef28450a", - "08758ca6be22d708f7e8488c296bc9b1a1b1cdc1f956c925a94a526add0b82ac", - "1734da6c4ebfc3682eb19db3e25ce3322286baef9f3872b802f85dbb62001c7a", - "81392bf9d4a52f7a2e413104a0a9ccfba33e01251919aac356f50e39e8d16e9f", - "4b722b081bd2e5cd9086679b8f22c911c3c0e5ab8714af38384db3e34f3fb257", - "7a812b9ff54155d2a2228d69a41b34a36257b9e9bc9834d6cc62f8eac6d2c4f0", - "5b4b07ab882e99f5a6fb76aa6ca50cf7e4306564a0bfe800bd310a31f88c9554", - "6c5b6ec11708b30265fb802761ab5cfe3cf187089244545f66216505f7a8c97b", - "9e1f8a31b8d9abe0e2b972d0f76ecc7412514f2ea0f3109f171876777dcb4a6c", - "c6abd0f745821d0bd8bf312440fa6513ee3be84754f87c33c4b97b8c9e8f01a9", - "0245897e7b72797e498056e2f7c26038c5dd74277bde466f7d2aee590ae4471d", - "c5aa88e9db60a02e9779166d3e0d2c7fde31aeac900f471f337b8682888e3d5e", - "d0146ad09a76b89e7d59740db0edd3dfffda7939525feef097768fefc9673d8f", - "413cab19ed3ef0b0fece7601b496d725f6bc14994b3b1556249bfc666b5dbcef", - "aac3cdd1249d81411b5f36a6a332083cd2827453acc79730c1701772ffb22b84", - "7522dbc732f6f90e5ec391bea8a818a5b93992eec0c048378b436e121f6b56d9", - "f20597e88e594480b373938f83c68370f06c103e1d88f55dc9d00d4a70ac2041", - "53fac15d083d1e2c13267bc68446bd1bdf2da0d90d24f381402a7be089ff13fa", - "8739baded7903cbe29b65396acffa76710d0df47b43aaff949d81c9c2234c070", - "95e20eff3534fb1c36b3bff327a01d15cfb17b62c90b7b8352a541d782e5d70f", - "974da4bc7c3078e01298a1f4ab9861422d7641c6460339e34d3729bb0b71e6d3", - "14f245724eff343c1fc359cd4faeec476a9c5b6c753ea7862e2d831e4095696c", - "fd70d4c895524011e8b04926686156b96153368dc95b8a45b5f726b9e0c6f084", - "780b921c817e940bb7d3e1ebc29a111ee31d88d2ad1399a7a759c94075e4ea07", - "6235d51bd09dbdc45e7fa91e3b5bccf98366b6e8eeed3368f6a293485612b820", - "e1634a650f3c7a128d42538317ede5c68bd3f47b4dd5cd72f4cb44d6afdda94d", - "29fd82c98a4e459c26667f5bece7eaf1464a3d2d0e0228c85d756ea4819343be", - "64f45613565a83503ef37cd3ea7617811c2e4a1c85bf08717af09f7c451cd6ec", - "125af32104cbd615f8a211af54594a014be16d39d657613a0a33f2896210fc51", - "48d091b4b56fe5d13fd1ac168d759c20b16c6b757ff0d24061ae9a5a4a8353e2", - "a3e195c0dc1e1aa1a8763929ff394e09c63b28fa3aae6753fb4ec4a17c7e3ff8", - "f858e47a113c42523e38037f9e47a0e2ed743a8b4fcb7599f9db7484bdeba6fc", - "7cfb766b4650e07ba2bca9978e9df0ac4f179ee0b65d7ca0d4feea55a246370a", - "df7f0449755ed0c9e0bf2f56c421270c5679f6e837923174d3c7de403ae67cdf", - "8b7225b50fced39aafa03efcc1152ae180f3eeb767a74e37129c2d727b052682", - "e8dd815847fb89d582dd22810d109f52c8c32c8873f33fe96c85dc095599582a", - "d29d95e8756853df0db0268011ee733f69162dc820949848d0572dd55f471ea4", - "3538ba40ebcbb5f1395b47aca1831b59261ea58b045ab2b1f90b4d3067e26078", - "d1c80b0348c7a17016ad9c5d390422575deee560528cc66de55155ba8672186d", - "5a9fa181b80337bba28c40a330dee69f9c1f72273f4539b52b61fa11ef6ef027", - "31174b9a4da7846dbe2d14e468702d3bc7ac8142f4f8c292ee5e26265f7bd25c", - "62017ec8c5b820cee27ae98f3131ad6da355d07e2174ae37da67b9e530a7a9f0", - "c6992180dfc4d16cbbd9b80c35abcfc0557fda72235de5586197194ba2990105", - "7030e5fd844fd2c4c1a8ca84e1befe059ea31938cc4ec9e14d44356ee0a4f594", - "99874203137176b68cdb5eca28ea835c55979d9b0ae93d64908d21a9668d8bf5", - "0c05fa6b31da7a1bdeaf0e45539dd06f79b11d9afc95f5230d1347879105e42d", - "a633f2405e597a5ca5a4904f227b21af4b67b1921a0a0d8fce186081bcae9adb", - "1a51f9904992eb3194d7fae77bdec621f31ec04863ecf34cf3d7792b2c456955", - "3b6f36ae3f6c4577fdafeb433e206f4d3116cc2a07a56264aa17fb666b129b79", - "bd31e0899a662d4985c9a774a8f993f1f8ccd9c045533e5a6c2f8c04e432cb30", - "930f96c96e1c80cfbd65e12086d31bbda1f0c60c4bd5be11b527c58aac30b810", - "3341567e8b5a59c3f1c6b27af329f7f6d6892a08fb20c6dbee3422c0f418d357", - "d962d7c537ac19f1cd061aeb8b09fadb6124cf006bb9b5dad02a1ac9ef5c2801", - "b0ce80803219fd9a92ef437811ae5c62c51cc5104e70031d26e6c7eaebddac97", - "33d48ce9f63ff98637ec97bfd64ad231259c56e4d49f210b35d86483ab4ac947", - "d7f0f2fe6f3cee98489fa3e305ac7ddeeec38acd93a873e033edeb22be6cf3f0", - "54d6d543a7096b10e67e78a37bbb5fb2ddd037f585b3f7c06dd53eef968c86e7", - "aa312ddf5b0d27dccc41e94ca0694b6bcf99fe015a9398fdb361e09ec90f66c1", - "5fb7ec4349853dad87796cd2f460d22a360f340a906d645ffc9a851f43747ad2", - "f714d0b70e6a45f231c4ce43aefb1b6bac88f3e7005a5ed812d34fa086808ca1", - "57c879cde58b11002af3f0b54deb8ede20b03ef12927be693cb9bef1d0d41b50", - "068df9aa5b5532a3603028b2681771a313d4e7bdc7c81d8c66e0db640fd44ab2", - "c672bb22d1ae0c17889296bba7112f3f4668b01e49697fe48646425b06c931f8", - "81d7c2a2e998b79eba13abaf9ad1ebed74e01383b49bda804ad7e110f8bc053a", - "dd57094ad836c86104d814f01e0f3f32913d5ede1c6e3c48c7d085261147c494", - "c777186d43853aa1a7f11e807cf5d8478647ffdb0d0e7ad5253378829060cfd0", - "4170df06622dfe3fbb7782c78a928452eb4801fac70f71c732a84dd2a84d3e74", - "8a6394a1a256b58c9410fe9c1cd369f99d0139b284d1c80804d2a462a38ec8e4", - "9a087d0013cb9945adb6b5f5d646317fdf9a1aab7702f1fb4af40065c24e58fc", - "79163edeb74bf916fb7085cd048079a9922446adf0ade92b39e06b38f41ff45e", - "3b6bf994fb76ad4c80de6065a3306171903bbdd9d50c462ae557dc82db8ba61c", - "808203c39d63f5d8fa0562038d048c874ec126ce4cd0e3bd4a1282b6b84a3433", - "e9a8dba6a8641c638ec33acbae53fcbf0ff15b35c536f5d689f19b2ee3a28ca5", - "da2f7f5edeba4ec54d54de5e937a53201c0914837354cb9e8e1edaab44a419a1", - "a993353bb408cb9631fe71b40008793b79d7a431308ac4e0b55643b21819059d", - "45125fa4a0154892b2e5225839768ea89adcd72f3f06cec121ce3f24dd7a69bc", - "6c91bbc229e51f40b8e5e4185968e9456eaf936d447900d869e4245443f25a1b", - "e59a6e612af5917ccae15bf781b37217f19f3e4e931a431c41b25ecac039ba3c", - "856be45cf0a78a381e864050cb656b3aaf14671d0918445ea94331a054bf3fba", - "0a70eb533c20a1c13cf58a4f5180cdca2d7b3ef192ed2369d0953645f8b1fd8d", - "bb5b2b750dfceb5bc0e441fac6f5428c7e98c29871ef4d96e67fb2a029707ada", - "a8f0abc8b2809471a8aa37ed31995fde6f4c6195d6b0fc9bffebda3653a6a1cd", - "f79e0496fe1a847c4e33f974554aa4bfe16b3d5f240751488b30df4583f6ce30", - "37b2f2d1211e3e550dd117072cff4015c617318afe5ff0df17db7523602c586a", - "e5516bf8333e207bdf0548daddd74f6c0720f04a426e949963d903ed1d46d9d3", - "93e3b9dcfd9cc7ce08731bbadf8ade49cb20a2d9a0a7f25d91ae43d71e3c3bf4", - "ffaf6e3f11e681c57151c42df935f87cc50f1bcdfe0d2ec84b70468074cc8327", - "46d75539b6d8845f3ca8594c64ea6c09ba2ee2b31ca910fe951532ba06b1b95a", - "6eaeb1222599229434ed81b4e3a1a7d779fcca82b0cb45b844f7289e25709775", - "56a47dd4d7a374b68628f7c1a159e28f0064d292d8ada0c7aedcd00bcb9ed433", - "e69bf1cde3afcde11d53a293d5deb018f5699caf7d5c87cf1b295043c1abb481", - "f7f8b990b11b4e1db1c34a77b0e26047c11815aa3587bb7eaa77c7fead4b3211", - "29d9c9da3138fac15f95a663053ad209d6553ee1fe25c173a98f2b073e975a62", - "74a78a4c3a5c3c03e980f00326f6bebf886ab8586cea2ca6d0819d2b14eee89d", - "8772591f24586d9bc5e396161c278ceeee52733b24e310496a8fdfa04df4ee0b", - "fe87e2f00bb868996802fa10c0c36480d5b73b3055538139f44e8878bdc162e1", - "ef188735467e3906acfa614fd6da9ab49b283c8157782af332f030f4a84a9125", - "1931cf3fa0bde6f4fb59f09e37877655b36add7528b98eb3cf72360a87d86e28", - "4e70cd009582ac4e95739f39d858f578261e242eef396a97f3f81902be75b449", - "3595cf94cccf1fadba0caa0424a784de8835b8a4645452c3b9cf1eb80bd87291", - "4efa4ddc6ed684deb329763e5e61294b5b94e90a1a44d9eefcd52b87d40a0521", - "7ae2d0bbfd62b1c281b9f4a92790783710e8823103a9e16b3b05f480f1f0048b", - "6150918df7e8229ae5fe0c6da3011070201fc27a0f69f7875dd6833f762a08b1", - "58be536b403c576096033a438a19e093aafb15dbac531e2d9210bc545972c571", - "977d936d90ce7cd1e3ac25b51537f6e92636e444c0233229716b6d1774157ce2", - "7eb9f9511d536bf1f48167659769a7f32d3ccd2879c47dccec41087169ea60a8", - "970822605b7976058b93612f1d03f39cfd93be2466b132cf5d5c4da4ee5cc301", - "fd1c39b816acfb228cc01bc9add6f967443d2342126883982338166e51278dfd", - "40cd4000c376dabb6a07d96bb57af094372ca3912cc4c7b9573408613ec475cf", - "d90738afac4de6e040aa6637abae26a02ab27bd9d72257ee4635b43bf24b9516", - "87a8c4309cdbf69509bda39e7edfa3e325a114c36c1542207bc27da1de1119cc", - "dbf8361be43ee20e0d838967564f01751f3ee602ca38f35739873087f8147836", - "695fc7d2ad232cfb9152bccd2d16466ec6b04919859cbb0d93014e34fa7e6ea3", - "da0dbc3d095a15187bce2a703f2ea6b601d11838c8ecc28bb0d822320ed08881", - "8e6d7a3f4f8f85eb63a4c6c67b7ab032d67a7ff4cff1b0484a78fbd47d1e5ab3", - "61eadd04f7ef49aa374dd2066d4411aa198044fa4bb4914443f054117a598ee8", - "bd700a1e5cc2b75481b894565cd87b26677f53e65b75984efccf762c9d8dbc6e", - "286f4192b8c213026214bf43c066a0510422194716ec6e234edce992dfbd244e", - "9e591a0ba7ca649be356c450d60185c0c6ec7eefcc93756924d48cf2d23b849e", - "1f36b48f8136721bf36e122d445dc05029064224afc5c01e21d71540781657b7", - "4e8db4e71dc45f54deac2745059c4e17b150b038e07bcab59b817e009e3eecb0", - "802f03ec919cb298277d09362ad0b747ba5c4092336d4d95ebc831e81371a504", - "504ac19d9a87bf2c9a5fed0a5dc97e350337d3a36186a7f7c35704869a8305b3", - "75063489728e94cb3f64456f4cb95ac54f86808c66355275897637dc6b4460ff", - "5740809144c45c30bbbaf6fbe87c927f599eccb4fc875f5bd815ae2bdfefe479", - "1dd9641b09374a00e0f3f708ccb6bec76d296e8b52f620467666dce2a796e05f", - "10e2f8b6293d006d5a7682ac6b9bd3bdb9f1779d9b7dda8f87c754c84d6e5ca7", - "be90230d40add9e8c263c6c27e60f03ae1fefa0b904455d1192edf15cc5c5db6", - "52974c66623ce30ee1b3873e986afe2aa84ea7e78fc809493ca7f567cf98c44a", - "05ad7542c36982d450a22f40bcc419a91d960a60f28b7650ebfafb00fbf42ab7", - "6b1982f78ffbf8edfb2a0d56af89ec7d9132f973e9a991a26330a3a0624ef63f", - "2e9c3e3eb92cf760554a8364ac9c805bad125dbf8454817ea3525125890c5ce8", - "4405580f87bf7fc3095b5ed599f1a08f44a893d74a41d91a5548e1827ab34c1a", - "b6f849b345393ba015b6885ea06a5ea19dcb2c42a33c78d81bf32653a7dc1eb3", - "c8e75f7bcc340f600f11fe4abe9e5f230063372870352d169ab3ee4e6e69aab4", - "b3812aa1c78575b2fc37c7ae6c86b4f37c326e8e019accb18baae1649e5b443f", - "956378afa239fe7a660bf8ea92a0e42f28b4cd365d4242e136c5fa985dadb346", - "dfbe3af7a163f590a8fbd04e709db762eccf179f2f4fdad59edcee331f28b9e1", - "e8e16680fcc75a8d2aa4356eeb3e6dfcd4b043c29a81fc9293c2e23474675de0", - "29e3d2ca05138ed5ab32789a8fa3a5669a471fa39bf4181614ac2e547f487a1e", - "360784b9ee84c7734993b28f23a3df01ee9a7cc21b53f41189b54f7190252f89", - "b6ac57c5cbe0dd0535ec83d46248d8b0a5e78f06e7da9bcbc04e51533fc33687", - "bdffe4a6e2006085a1c01bb9448fdf80d1c8be33226ad13c74fc4dc6bbca1a81", - "2590e3eb06f67fd7dbb495e9e26533a563b6846041459a54489e6d9aec5bf056", - "1e901b50da2a93f203b129bd1d5e6f9cae7fe53b81905505cd1ddf3b294cc3e0", - "25ade6f68bc4ac973112bdcfb476a766237bb941cb61e26aef870420465a7800", - "b96c758949b5d3dce8f57a8107d3f4714e574163a80e07fac74e0c434b6995ed", - "fd9a0f467c02ebfef650bb624f9362ccec8fde0c300422811b44b30551dac9c5", - "a10cd2ecc557310c96279d8586b74d099fb6401012d1417ee8aabb77259379c7", - "94bda5829bdbe9415d2eb85f67f8836df9500dc33735da974eb089e6a46131e0", - "313b99f814d88d2bc0cdf0f4f8f3fb3d50cfaf4a25079f25e666503d61bc48a5", - "2db487df0f53353e54cdea5c8c8d80acd24e646437e40d1514b0ec79e24f3585", - "5bbc8384d0e43c9cbbc43cd33a01bb730e6e2778a612cef6cd9adf440fad9526", - "52e377ed6367059f569e1014ff4e7dee61630ea38b3a7fdc6611a55bb258c077", - "889419106263b41ab9a61e35dc1c9686e94af2b296d5453b3644fcb1ac3377ad", - "c5fbf5390652532a2922e41a5b2437797ebed14ff82337582bcb993025a83140", - "62654cc8235adc1463f40a934a1977c8fba1aee3b03f406cc75b4f8c69bd4cdc", - "c7e765523098907e549da6fe77cbac23f111e334ba58079b9d9a8ddab3d4ff90", - "4c495b573678444e1746d7892d226e0e6d7dcd9dc723eb3a7876845647d15eff", - "9e8d23d0c257e01cdd2f83ee3f694203e8f070d08b0731de5a17175daf7e7ad8", - "cd1ee48d1f9f38648bfdcea8984d388a09c7c8a0414a269cdc9a31cfdd219122", - "58cd49b56ef23df4b303cb13d29bdc40c291b44c73c4618c27aff776f5de15ef", - "ab6df1c790038a82a256a25d656330a9ee5b1d751d5a7516257c0b5a16d5aece", - "2b582caebaac5e9ecf7e570804e462cb96ac137a060e7357dae65af6b77c004c", - "f2061a6a5383d95910490d770b61d06f4b8efe9dbc8a85393f656ae8c4cec78b", - "0a4421df6a44a35b0d5a00023c4810fac2f7ac0cb186b47f9c38c813c2cc89cd", - "c316e6c77460efee288d0166fd3fd3801da22c6f8554762287895c5dfa558b0f", - "305a4bc21d174f8fb1b28d51d890c2ee882fc4d0f24d453573375eaa248c9b1c", - "40526b87f180e0984ee7dd2bb36baba2f45525840a355c7478910783b7879b97", - "a5f837c5829ab61ab30f72047ce83e9b24cfdd325d12c9669aaa49c33c3c57c2", - "d197a1eafb1073b19fccfedaeda5220109ab894dcedf41a84821362f4c139cbc", - "5504dbcd4e11d2f11a03b50836b950929713f43395488e66365bd256c3f60506", - "8fe48c1e7d04249c772ba2ec3bb9d27aea9faca2b55fc4e8dba6c4e287afad16", - "8ed138a3db5e7d6e18c240a753a1d97bbb0d72d8cc3a192dc7bcbf768058e8a0", - "5418650f96efdffc205092a4d40759b090b4865132ff257ecb46f89a9a2c4a68", - "05ce9a65f00d28b67724317ce113427e88df589729a7a1ea305d733bccc53ad7", - "d170667e08a15e92ede444fa3b139235753c5ab96513265813660f5e19773ca5", - "c54e063c5d261b610a40bd0d0a1ccaf5b79a6bad6667574c802ef71396486669", - "5831d25401d7f305ac6da1ee55d3096329811f9695026aeef3b8a8f6c92d4b8d", - "b0cf79a9e27315b11e5b3d0e03645ec782365608334d818cc0cd0ecd3222e3ad", - "c6045671c363e760e6701cb544e7e369d80049f874c1f91d253754914c2f9254", - "701c1e9131ef4d8535f28a05c93c8a3fa21e6eaab1b3b9ef9b260fe48ba4f94d", - "3ef6588adff2269e94e379c6e4703cb32085ba1963fb25812a664da4abb9f888", - "eb15d6f8b8020bf18a15eba3cee07c75568f02f8dd220b82485dd459ee6a0a45", - "331644e94ba8b33314a9e02dd74f70a2afba00d4f31d9130af6f0298b315da59", - "55b0daded87258169a2ab82a9cd5c2cfb4258bdad31ec15491a5d2587e5b65d6", - "2d76114b3b5354701f62d308599044332727485790563e8cccbb378ebee09070", - "1a5ebeca9a3b7efb1463407927fc224944f54ae80d63038c91e74a61753ab612", - "8d6d794234a13100c7ee50b326bfc903ad7e32cb223c475dde49146cc44793ba", - "de0cab5dac95dcb978464cb4ab675957d7c9fd62f3073246b360df9bbf9d3c0f", - "dc34671c5c34a71efae5cc2c91f82c536f084943d7487c46e9b4f677e442c641", - "3e4e4743289551fff82d04bf7ef38bf6c5eb02400457a6ea398f1c5d7f44a14c", - "3168443d5f7e99252debde1b659626589ce9018ce4e0b9733885af83e63fc6a0", - "e657cd77f965cb657d50259024353df89c398986b0896880867f498670657c02", - "51db63edec4e1433810a01d172a2c27437e83488e4630a4d37dfcb494ec0d788", - "379ca06ff3623ea59074ebfb6d42c1fb914182fd72cb7785e4ee813393262003", - "51d21f7ffbe308d9d24d057bc40ea5f3bac8dd130329666da9da3868b2f96d07", - "00bb28b8aca7d84a6988402abb557c4b6181c17de14b5bc42549c53c1727bea3", - "e08e347f76eabd6c83050e8a0b6c4f462344f90ded6203c553279c289894879c", - "09cd95546c0f4b3abd1754a6ea66a576a113b09f83f8a53a7da9927442513f0e", - "c7c92565648d3c3d6d6a666e69625b8adf2a3a1a110d3f9f54d9aa8c2954bd2c", - "749ce238859a6d683c1e24ee9fa825fc63f522272fdf8bfcd520b4a5f8593800", - "bf8b030d28d259a40c5a78148dfb299a1c0e75d1888a0d2996cbe23cb36e802e", - "3634c8c639144a3c1e5f2416f04f18478fe12bd64857bad2a171c113f605774d", - "a8312252b315e288a7e8d47202455b19493c44a7ef20b49a6cf6eedaad30e013", - "93ce10f66388a3c38fd15d1ed3f119bd4c05ce8d7035e5f6c038281e94121aeb", - "da11e301e67db178c5c163068a5af26dc15c96e95cab9c818ebac0a9b18b4220", - "30f9aea5523a0cf438f7dec4bcb6f107b5681447f27faca81d3aa9ab7ae1c254", - "714ea282e6512d6f40193594e4a12c3b0d00c01dc042d30d8fa7b5fc289fe095", - "84ac5a4fe65f8b5ee828b07db208db2e2a9a6eb980ecadef2f720f9c5fddfd4b", - "bd6d6535d5a90661e4516a80e13377d185793814eeaf06ae5ebe0acb32329e79", - "ccd7a4144c70dbcf894332c9f5924afb7320d0e30729b5e56490bf4999911f0c", - "479fef441479f08e47751cf9c19035260b4e7b1a6f2db15f7cc5e8c63ac2576d", - "841ebe7f97e2985f9eb9b3c0f6603104a61aabfe08c581e76c9786632692255a", - "2f98ecd24b21972bb78474065aef20474f6d1913a5ff28f7b9df2a79a8eed31f", - "acb172ad5d6dd387eb6c4b760590c96b0519eb373d83703242702fffad8da70a", - "6d70dd7116b5d8a6d484dadfb8fea2dd0af9d47d1859052628d8b38c31da2591", - "bbb9302f8ddb6d5ac4d2d27770ac55e7171221eea848cda0705e335551c2f534", - "15872c4b1fc7b1483a2fd5174b9ec279813d83a1ed0d8186547e848a8fe41836", - "3d3a79a0e7e0445071ddcd9154bc7499b36e6d204a7e4aaa3614b1ac10f4a4b9", - "86e53696669464c81f274cab1f372d9a11d22fded877251eb7e0fdc528758da4", - "7f99b21407ed5342dc5f0c8a71b977415fd8eb06625c4ec301c7629f5bd12993", - "4770d1702e21eb44975d5fe606f1e83c7a5a086bc9d6915a1e87b090491ed428", - "34f3477288b5b3d80951b44fe623a20f9be94f2033dd373bb97870c329397b30", - "cb9dd1d3229dcc2fc2325a18df22fa7f4868899ccd0f0b7221f7d8977cad457b", - "46735b84f5472cdfbfcd685c4f9fb5ff9d291afc667f31e55c594cb727fcb0e2", - "aef3791ee2e592e74a1b5af46dffcc664cc573bd4680753d4c7505155020a634", - "36d0d0f590114f15402afb532bd41382e9bef953227779e64e67bcfbff277e9a", - "536a7c4d128c445d96e3132aac86920420f15bc88ed52adc606360a3aa569072", - "095644d3a6e4fccce02c86afdfedfb00c8b0eb9d642160abc314c172adfe4cb3", - "a5342b887c1ce6f4db184cc3ae870ec8d3e97a6e8d8d76a6814b89a38103873b", - "49d0fb5cdfc6b7ef6eea152a5f7abba7f1b63d8a7738c977dbf616924134017d", - "7317b3da75bac943ee950cb64566b6e236e1c3060cefa539ffb316b75e0d6793", - "af9e0adc3ea94519bba9b5dcacc77e28962177e654114919ee2a5574ef09fa1e", - "0af08713e56ee537a2d1c58eda3dc08a2ce2c59c8ff6c09b91da6dcff1dc42b7", - "eb366a0aa6cc5e3046a4eb20c4c7d6cba212e409c4d0e3dba69656ee238189f4", - "b1d18f90f3b883ddc659403d9a3e209371fd039964dbc4433bd4f1c5aedd3023", - "0f362e915ed4ede85fd96e238da981832181a82350a58a72a10dd5cc6bc05f9f", - "88f09f73ce6cfd2ec874f3f9bc4a9a6dad5c68552c428d13f0300c7771925455", - "1f686cf5f7fad64ecf41534b5e222e7bfaea5df3ab3046749c6d1bc0518c159d", - "e5aeecea9a42e001442bd0644631c28fbcca45bce9568d2be4c64204f80bca49", - "7ec8485f88e26772eb6a11573608c5566716a953d7a238da3de9ce86a87f7be6", - "700c36744a9c3193c48257510b4eabc06792a90ecb5c3b28671f4a795ab6d586", - "de68ee9c2cd990d3377a4c37217ce3ebc595e18a14b17640740dbc7c3ff62c8b", - "5ebd68b7fcb478df0cdbf7a419b25b1553958aa136f97f23f3c3aa206e0d42af", - "72eaa3a2a92c0c1c1de6bd5aad6ba3457ace80e5375c632b1bcb201e6c630a98", - "802a7d6cd421434226b673f4f4652e81c52d35e7e78f57c9f7da98740800028c", - "a7513b253b46a90f45cf1c1a069ccce7fc0f9fe36a9346d4da884009f962ab2d", - "05f63caed9f4a8f318b65a94d151fcf9a05abc441e85994344744a671225f23a", - "643af4b80ca8d77c5f9f92b5f3fd35151032c84818c3fe61cc883ea4df5bb5a5", - "5fcf0b4096af7a3c0e8a798d0648df9d8ebb688cfe7a248facd55c9d87d3410b", - "e422ea5cb8ebb398bd374e72635c1cb2ec195237da896eada8f36c413106fa8c", - "f7e92ffd96f8cabbb7d20a1a23624ce33b01774adb66826cb88f0f899d7ae450", - "c664de9873e37d0bb35b6791871201cd27b03979b36b9d8f7ff5f940a30c2099", - "19f75be5e8456f89c6b5c7577cb8a0e52e1111798875ae73fc65569aa9dc41ee", - "b7da8a7d5ab2fb13709f3c938de555af03ae49ffb960dfbf6161b75f37e45fab", - "14a483075ccf1daca7e670bc7e2e47ad6a6c7e172e06f364b4af7dd11667615e", - "431118d5539dd27d400ac237ed4a05029c5dab9bdcf353bac3959e01886fc297", - "03a69bd294bba596ae78aaa5a62a9d4094dbe6cd357b89f259edf0b454946e60", - "572661d8d653f3e9b4188fa716f73610f0400266ea7c38717fc287ff13140120", - "233a547844fe9e2f396fd1bfbb6b8609f37c57a2458745e90bb5f747c8f1a6f5", - "f423148591327bdf816bec58378780dcc1540fc8d9103f8499587aba3543a5fa", - "f29e261f0688ee5a4661e1f21cc303384a2b73dd293865ac0e4c6d63a9ab7e63", - "9b3ec5f10a43d3e2f4d058d274dfd68ac2284996e299811fe360d62046f031c8", - "d14392b47bc7504cc2400067e26663ab76abfe20333975ce2e72953d4e9e2640", - "1ea251bc54e72f0e0766e1c690cb9537af2d5cca8895933ee762c76f9f8b42e5", - "9e63a0e676b56a11a5f20a9654b2610d52c40c2ba53b699f0746c885ce762f68", - "2857d9344c15c3948b14775327a7a310da48cd42724826154365b43760b2e63a", - "0f033e757bc667a8b648025641080f87cdfb083c1c636b9bf27aabf424d8ed40", - "1effe0353d98ef85fa4699b1c11563bcdd5dc6e1f76551ed6f84703aeb2b8164", - "55f535ca64ae88f079e3b3ed78a738848889c57a6cfb6e4677eb9cd1c4da028a", - "6e0c0f499845ccb3cd4382dc594e895845a071674ea84af71708f54a9d47ced4", - "300ace62a9c625675f48a911859ecfeac34769ee1f34051466cb6a8e40971617", - "36555003d2d2ead4b582871d0766bea1b65523c41a8a7bc699ddaf6c697d4ac3", - "9982cbf19e7d4af5bda8e452866fa1983df109bfd87013307487b2f9beab56f4", - "00f185b0e08e87eaeafc74b22050ae0532defa5f0628fef51ba87253c6c69a74", - "a9cdc9b8f70835a18d6028b26a9d8ec4969453e88b58fb3f3534d3cee3633f3a", - "3e7db9cbd41470bb5f0ab7b17004a23cb58318ec5ddd4a2e3c1b5ec2b5d4911d", - "f51158017d9011a3e2b6b7445479fa021c467730dafc2fdbcb5fda73873e1671", - "c99e103367852673259b0384fe8cc27222f2502367aa57137ae2c60dcc8d1e57", - "f42555f2308eeadbe6dba3667e14a1728e2a8490182594b667664a4c3b8854fb", - "da6f65ad00b4680394c06218942230f5af9e916f5ad4b77e794a83fc0ef241e8", - "11592c0196621d746fde4f8303d5a8a7b450ab0df72aff6688f09f7c544baedf", - "d0baa98f3b4936688a8e639b497e8172cccd662741fd9c20eaa27402d3c3387a", - "fa8c0f1fad467ddbbd19e8017025af0c7a22f6d632e7e96d0f4c4f67e9643bcb", - "7e42ba0a90bcea0c779b2286c80cf263a33426d9c1e34ea4731d7e2ccb25a417", - "7ce3b0757005659493a4f9c7a4b65879d0578b182888ea77062fa8bd03f3c3ec", - "845907046edef57bdbcda05466ab237d503efffedd224bc92d80279244992922", - "f4a5ab6c0aaf6d922e3437d46f915b822e3d1e2c61960b1ac5bdf8e484b22aa3", - "91b3536832ddca895f0c69c016a8b0809475c118d29b73d64d285068a1c424b4", - "cfb35416db5eb420332272bbb7c131c652f8b6b0f975c3d2857718b4a2527ec7", - "f54b46b74802214edb56d22f05365288b5646638fa44013fa0f80ba6fbf66217", - "4fbfb8a7e2c74ad76ec3f73485a8267cbddb4e61136d64ca20bfd636d14e6563", - "972e19f3669e0ba7db68fdbd6ab5e2be042206e0597a4733f76ba15b8e3156d4", - "a08eb45460a76ab0e495fb81ee9a9921ab63a491913c036648f5c8eff44761b7", - "b157a4dbc4843a31b34dc685bd0ff43e3676c6a8e3abc71ab24b67a23b70bd81", - "f7f295a6dc32943a57a33e238c8e76083f422d9e12936e7df08462b38a9dc8ba", - "5b00745eb7b32959ba4bdf88e1b2004189faf3f58dc3d0652a20812a77293dc5", - "66efe465e8c12ab5e46bcdfc240951a1c7006733861e77237aaa28519e16f234", - "90250e6aa77914f6c97fe38db6e5d16a892c9825740925e855f116360ed456ec", - "15d9269966a27eccdcbe249e1495438e367a0c237c23cb100e46707410de6c4f", - "4409c934d14c8566a17e5658a0daff071bd90aa54812e10b36dadfc0d958b248", - "3fef614544d595b2c9baa9f2c3de4376ffd8e1e90958f7ea848068f8debbf649", - "b7810b9cce0612e1399427904585195d1f13bacfc7556a71d4beb757f4dcf51c", - "94a3887401c4ab9748c8c277f2d0b398abc0a2c9192fb46e80c21e4311638a48", - "b379419cb95f9e2cddb3e20d8b8f1d262dfdc37173e98403f527c71da7d44680", - "2be453e450aef30d7357f941525ec9c8e2ea8e6d98b194e08a2055e4e6dd85ae", - "f58ce618a96598e1f36560a5f81493135cc0a5118b20cc3699565f9d1ce28240" - ], - "jsonl": { - "path": "ultrafeedback_train.jsonl", - "sha256": "1677ab31d7443092de3f907492d336c7f9fb420f60312928abc037ced1fa50a0" - }, - "parquet": { - "path": "ultrafeedback_train.parquet", - "sha256": "79b2bb886b56fb770f1a3c77f34e709def1e0e4b6c299dd164cd2c44367c4094" - } - }, - "eval": { - "count": 512, - "prompt_ids": [ - "f6ada56b9e9778c17f2bd423a80195b253305facadaacc3d7f962751a75aeda7", - "206b7c5d325784cfc41d7d7dbc71c9d9872a7e64e7392ebd0371c512d60e9a6e", - "022cb84461bff2df0c31a81546908a9aca406f6b7959386cc4be2fd09314bc67", - "20a795a383449fcfe0df88091e23ef49039f655fc5056f80c410201fbc6cad93", - "0a30773964f0aecba3d5781c17af5f99d34432e08a95c50f8bd28b0450f3a231", - "ef5a3d0c28ef0cce3244a4354037cec949a1a4bb227ab95bc4f9faf0444be6e4", - "cba334209e1208de90f70864c792f2364204e5dd26d5067976addec68b4066f2", - "1a410d3bc9677f67e01c6fd1e7e163b5f8526bc9ec5d9fb5bd09d78c488edea9", - "2fef26fac8ef63829981022b8a368881ad4f763b6dc2ac95f4635b014fbae12b", - "c199653a4cad2251a14ee5c0c554a15536b5086a942ba5a9666a2ed8c7b53ef3", - "7eb7819a2240d8532605da7a9a930f1c731766143d48b73194a647c0e5f124e9", - "22519a24d763ca1d60ad87b8c984c1aea3e02c8ccd488bb8a62e3043653492dc", - "eec33c11c0aaf62414ade529ece498b6ecb73d874a032f0c7858751d6981e800", - "2fd60f842597de3a26d07c0eb813d5034053c0bf91740f302d09dd5f773e2fa2", - "1a28050856d3853cea5a6c571a7672dfbb23da5d89830696badb7d37f4af63cf", - "b523dbab7cc280ef8c763f98c42d65f190cb49dbb58575f5a872c8fdd10661a4", - "8854d06d15cf0cc4829ba9dd62c402fa9f68f578da375bb6aa391ebb3ca5507e", - "cb963530ce2fdd195df491b9239fbb7bfc8c78bb25c90a6bc21ebf8d0219616d", - "318d34270e67c271aeb9ba7531e0862417596d3a6bb118b777bafc37f46022a2", - "12fe99048fb6e1a6cafea49f4d0463704d6bb1b1ce123f1414452cabb3495d39", - "c7892dba9c5d58e26aa6ca77e47c2d236b95c4ef98d2a105c07c56c373618d0b", - "02d1ca6dc70224fc4d89f4b4301ca2289c8efc5937256f060bf27391f753388a", - "452a65627abb02d5006673654abb52fb0c026451bb27d480c421f75f7bc6aee4", - "04f09626b1e4d804777fd9c2b088dabe0a297c4818d947d29c861e27d95f952f", - "ae4a3eb718e68a38c09dc5bd41ba3a8d070a20e59d78f099180e38abe2298664", - "49da456bf373a8e4d992de8ad214db7f45e3c9caba0e7cd47e41686d8f1ca2b7", - "570ab698280bef8a1ac1342b912cea04de7d7fa55076c48cba5ebfd1b3903426", - "63d797c2b6240e7629b2f88d8ec8ccfe1e320fd4034d957718471355dc0f98ce", - "5c84c60ada03497bf158cafc0c5ecf46cdeea59f2f9ad071614300bb0215ab68", - "631866fcfdfb0150bc6f8ae9afa8c0db999a6fb7d5542c1370b753ebd301d7ba", - "4d25dc88274ebe097009bac9f597047b2776f9c0b76ee3c38c4920e42d66e931", - "0224716f5a6d92cb3d2b24f3d892bf98bafaa0f4012d273b9ecd67395c386a0b", - "1d541cdf3a09d88f486a043bd789615ee08e151224a2aa18cea889f54339aa85", - "f590bdb834c265a2948838e442369c7c541cce728bab8f5af3e8e995f5d16b00", - "86ef505999c4ed8b8099e1655324b01dd553d4d4af9eaaafccdc48993eca96e6", - "1f86130766fee79a85ae22527dc3801bdc7fa44f2b5671eeb3abe471720f4966", - "a46a0583a498ccf90f554d0e260b8ad0a21490445663b1689d49ce52db625700", - "0ef15823ff914cc7926a6bb83226ae9c11dde49e68d5fa5828b30d8d30249442", - "fc3966ea37f98e1a1f6bfbd5b6775b98101afa42318df9fd3e05d0e3c15001c8", - "a795d87ccf645ecaf293831a33646cb826d425d12654fdb049afcb44656c94e6", - "605b1dc8bb9f76c3513ad2416590231d774cc5cdbf5e0e64b6f76f12cdce21e1", - "e19ea45dbe8320fa803f9767ef2892465132b2468fde10c83c7de2899b183305", - "3e1cd4a96a3d65886666d8639eaada205bfc562ba04c753aff67fa7a51f0c076", - "9dd93f4fb4279fd2d86e329d9b78dc233522a6098a2582e6cf22b4bbf6ac3aca", - "3e74f0cccb4a5887af73e9f606e42dc44ac9d4734d1e19b6864d363ca8086bc5", - "ca953d65afaec8f63827ae649551c445c23e946945e0cc161caa4049f9cec9da", - "3652ced8aedb685ddece1befd637d57672d6bc41285088cd14a2ab100b2449f2", - "37653c589ff634842af4f453f56cf056e43c0b5afe948ee41a4a8c6e92a15f1f", - "316ee529d1b45580135dddf86befef3c8d28a9b1ce7bb597bb77a07611fb14eb", - "5ebee7e298ae8dfa62a8aebe586ba0da4e8092e9b4107d13953922eca08007bb", - "0bcae0ea7b353dbf3905bf2a4d6de2fa2b757d18e31ecfe6440961f1063960fb", - "ecf91b393cdf1121e91067b7e8549604347a53054af0582b9e0e68557159b710", - "44763cc84d357ed1eb4785190ae602956a2056c26dd89191c7b4a916ac18e531", - "2b4a671ad90b727df31d7a5b5150c803879aed3e57b3d3985c7448a76895bde0", - "f30b8faa2f0c5c4b2967ebe9bc794186875734bc1f65dddeeb405160d8befb73", - "7326ad4e8274a26960df420af11a51a5e86f62d92dbc12c450c30e7d47763e12", - "bb6ca6b5eb0277836123b50ce2fd70fabd2cfa017aff14027f3625af8108ff06", - "84ae18fbc334ad45555704f620549e2d3c06f328a6f9375222244529dc4f7cb2", - "481629a712a1e7f0d589280f76f945dc501b373fa433b6b5798a78f86231dab2", - "2f9fd05737c9417c929f9a89bc1e1967bae8f799e62d71834d09e86bae52401b", - "73d34feb9a00f4023d5ac83c5685ead8bb01b606249a5b4415b901bc9c237273", - "74c626b57862591c77c3e237f47e1c0a5602cd4b02c90bdd74f11412db6d765c", - "24f94b9d7488c6e5e0132beab13b85dee2bb59ed1b7fd56cadc244ab81c8e0e4", - "af42625aa53862893c6f02fda04cf71ab41aafff641ee5eef83c0a5fcae4c621", - "9c218f20c7487b9a1b5d7c81ed8a6f0657c85cb3f2970eb09a7211cb57040542", - "cb18a58790b7182b0ddb73ea89f3b04fc98354e682317b3d24587b0122d88673", - "1544e14b4b29cfddb9e7fde5d417198631b81fcc0e197f8da072aded648e5f71", - "3869c6986f91e7237fbd5da2ec9d771cdfe85f413907a91dca8ab1801fe202a4", - "b2d90d67c95626a0c2a32a344e47027fafe9b8f94a08033784d6cfdacad05160", - "47738234316dc5ab5ffb07a61c8e75f4b1763c2f971a82094104892bb09cb424", - "b1a4d674cf19261a45c41b9274d636859946c4072ab04030372b350fc097a2f8", - "93ed266517bf2658cf146567c1ebcd8fb665cb735bcffc9e616f8d7cd4d3ba84", - "85ba2b142b28c234e97fd68e96275d9ca449ab71918289e3e3065b8604c4f8b8", - "47346fedceb37cd8261325c487894f9f66e867cd962c5f489964cf7be8f8ac25", - "c79e89d993ae12eeb31c9e135b4b69c858174b584d9c970a2903cbbcfaed1a9f", - "7d0dde9cc945723029533ffd579318f522023a5957496d3406320780a1faa5e0", - "885b435a6a0212724a3ce82477efa7d32792c5b6798d0401953d486c5d3fe7cf", - "6fa7bd820f04e821c0f7e6914f316d55acae44398fa8641d584c2e2fe262581a", - "6a4819be75da11867123350c46bfe9a32b960a8e9c0b56c5f9d21d7f40a25ea4", - "460afc9d5e81e6f86212622dd8c502e09d6781348c60d088c59903b47b5cf916", - "99e613365d476d059c7b6a1117f868bac0d7d7bbbfab7217d22ba01c2b0f868f", - "411eacb5e5f7538975abb797c7e470082d2df6626e7a819746d721fa8e5221a8", - "2b6715c2f665f6848c84d5597e9766a3a33d6be57a61dd217f6c78600a526391", - "1deeb9a65d83d394d64ffcb3fc066758040ab92d67b8fe2bb82d6224805b0298", - "8fb9c717886d2475b48902d45cc366924a66272dc6ab099ab5401be218b7a73f", - "fca0e139accaee6112e2369b8d259306c294ab65f5b0c6c5eacab11a5a525663", - "80c1d0c60506dc98150d5755502fa6622d7183944c974ad1dc7f1bf7b59468b3", - "c1d905e457e3c2aaf3c2158a54add8129ec9b9e7016aa1f624e807fdec87196c", - "3dbf1076254e54cc69ae397dd0092cea12e26e87aecdec5902d63d5a246f3b86", - "09863e2a58af64ae0ecb0a2306a56c437d18d2b76ce3d7dd10a3edd0413e8321", - "fa4bdcc328d70ee009cb637fba005492f40983e812adbb3e63d3cd7902d278d9", - "915771716dd661d783537a90c4876af187d00bacee4f1128d6e895ecca2b59a7", - "0918fb9a24fa7bef1791c0ddd35730e3b5f8925e673ec6fa887459773a54065d", - "8fbb87e9231c93e5fab894a66275028b38545eb532171ae695af7f0dbc9e894f", - "ba52d1a40d9f9bbfc45402f18c829882891347339fba1ba8d55d319731121f4a", - "8a8a0193717066664ec4b9d9e3caec4e418872dd032bda745c0414b13a7487ad", - "bef5aeb3aeed0c9f9ceec9fbc8a5d3e7b7f0c2b29069e13a252b12ab51b3929f", - "cb3e08940ad32c21669273d1d1747b5a47f950e9c75ec38562ec516389c76fba", - "ef1f228cd85498c252680f78d3bdf8393bdb90be6d95bcd59e7623bb40be050a", - "9f355b270159b83511a9c2248b4bbb12eb6e489aa3a92ccf6c29256e6ea9b06e", - "6437f0b92ce92c315f2ff143e19176534f033b7e7c8599f6e1d3a56fbc681f33", - "b8ddb4029e5829c9aab98c217e7d4abb1805c490c708c2e29d339ce71e59e5fc", - "981e3b36ae9d61d79f4f2b38c13a54a5fe00788065a91cd366fc8661c0c8da5e", - "9d9d43d9e7796477ba9c4e8f77a0daa92183769a182d0e396115d54e4fab6ede", - "d106799320cb137cbdbf8460b8dba4f8998c46a5e9121642a826bed674a1a811", - "f76dbefa1515c4214e0125d111ce3fda41d2631719c41f6fed193460911ce1bb", - "6b3ae881e96af61e14abb7989a5f68928625472bbe93ab1cb8bc7ea12c984355", - "6dd2459c3919eedc8bfb117947119ff2e4fab2af0c395a99be20a4826ca5b997", - "935c3fb7b0262e9a0eeea69e5a8a27a1532c04f7b1cb45d9e2b706cb71ee34ac", - "041d1ca7ff58a8861d0771d760f9948b02ee0f3e67ce83ebd2d8d30d04d15a4a", - "260d511f40b1dc8bc28fe69f1fc428a06cd13b1919c65991d00d0342bce5e3bb", - "ddc67a61c154c96a06f866529589222eae778211155cfe0612e4ea21632e7647", - "39f9b04ff6251f6148647c056e0e39125e215d5120f8d7140eb90811ce4bf3b3", - "8a37cd05d2ef305fef2f5922d739a224427017171647ed412daf30c6ac950fef", - "fac0db76463f5c17c8cf5e0a25325c0b395017f97bca360bf609e2b674ec0222", - "3a3a279621e164e08fdff6cf82e5c77d91ceb53c4f233c7c5380d2185a45f609", - "dae2779f605d985498181eaf155d7ce98bd10db46dee5f451077aabf4be26336", - "77164eac11fd52ebdbe9803bcfce144e56dbd05de2142209353d2c0971e6b69d", - "26036bbe05466e2ba2a4406e6bd6a0fd186fd7b5ca68656a26a15fee2e7384e6", - "f8db37b06dfce13a033d0f33132ceccca74be4c054de02d5c57b239c3638806c", - "0382ca1d7acbc9006104690f41bafbd74f3b2689caf74d968f807984a0788e00", - "6735e53abfa93e479e1990ab3aa974326216bcf2b2372a6de893eb94e36ef489", - "9c4f793d0d477f828d77ed1f1f528c8260bac184baea2c43a2a1b34865f171e2", - "be78486affffe4f57015a153c5529c949aeb7511e1f30ed76da522452f245bed", - "1e956fd0ef6b40427cb12f753f37fef0605b0636e078c9b88b82c456811706f8", - "c7a1228e669270688e4bd55ad6302e6c0ad0b2a51be65c42439a3f5ba62fee3f", - "bb48cde1fcc94f514d1f9386e0f734e95609cf48e91cf82e682e55b3b6118394", - "2c2efbeafaecca771596b700c82fe9f4b3cc2f25963e5e9f29211a12c7709e36", - "f0b30b783de62b4c7516f641807267a0a31904498af70d1a6b29cb27bbf64cc6", - "565978c026b1ebd3159e75572762cdde0f6f84aa6140189e72b16195ddfde7f4", - "9d00f95148f6da1ba980b353a353ba8004328055b087e55d016ae97f6ed7d034", - "9b115ac71e0aadc1a667e5453b8447eefcd68d9e7ea6c0e1abc958cd7cc9a6e5", - "8b2f332e97657fa5ceb5f23f5a18aa2191f2ea2c476d66c10256f7d1395f5df1", - "15837ad2725266a35255f91d2e023ea644ede5cb9d7ec9270ab3c6dd6449a74c", - "3c394d3df5fa6b967de6e972d7fe4830cdfd015f2f1b757ce278d16ab74b322d", - "fa0fa7930ac74d5df155adde0bcbb0ae7a27b3447a22f484080accb923c5730d", - "ef2281473fa40ed980219dd1447f918cd9393b9e424005851a019c23c1503cef", - "fcb0233fd9dab90553f63989f61ae58486317c225a408d815ecffee9c56c88cf", - "ae480841fc3601d1a6072ab265529273b6a8156d27262615741d0434225dd56a", - "6a15095b54d8e93b4efb605250e59dab2725f9351fec512daec94f6dca814997", - "58b4af6862291b6efef9ef2d31540fa37ff7e253f6de51be2257faf028148f24", - "ca6f15144bb9c8793d0bbdebe3ddaadbce8cffa2f3a7bf0186c926eb76f7476b", - "bee687ead9059d37f567dd333ee4cf0ff2ece3b2fba91404c57965b79ff0339a", - "7bc97c8ab6c07fad3a420f2e86ed69008fa7e8b97380170d08a77f33ce81a039", - "5fe750b9f9e3544656c6af4a0733619a0db0059291c1dab7f9250386daa8ca96", - "e1ba601807a9b2ac083e7e87eb2e4df0b36158cc3ef1291bcd25321a408a8425", - "19d29ae989ccb2a510f2b29b5dbea779ef4e3ec25b97e7b21cf799624d3810c1", - "a1847d35183d55d57e57bb0775024a3ccac6234de8d6bd09254145597debc251", - "0e3658d575a7276ebe01432a50770a20750c951bd3eee9fbf5003dbf1f860193", - "a16bf2b27ab5f2bb5a18cf542cafab43101da5fca1e717a17cb128dcf5448943", - "a2c6d226a587f3b828730f12bbcf7b32a6360131b3537f87b51e2557586ad598", - "ccc53f000d68d160e4596d6d14097aadda8db7b7595bf901ce55f8e50b4902d1", - "7d7f55ed7ebfa9c9dc44cfc3062a8ba90efd27a5067181ca339a8ec8a83727d7", - "dfa6b6c25afd247316a7d0f37dbf5421972c32683f0d830e96315ab51ae2a834", - "7e41f46b0ea99929f67b09aa7ae4cd155ee1c1db791b76814db07be203d08bc6", - "1ff5d1d68f3bc11c66aaea4d2f68dd435f9026d1cca7388cc546c2151f3ecd35", - "42e0b42aed3d6bed749412693f7526cb06853f122d8bdd77bd17f999c9fd2820", - "a1c9e8c224b0eb22ff2c9f3fc28bee647faeeee4ca8fef813b99b2fda3718dda", - "e53088f57a3734cdbe5bfad94d111527434402712d8af8b8a3be904ac40ba2b1", - "34fb76eaafc3ee432fa22def70fbe92630fb020659f9e0b63177d57146f50e2f", - "f5ddfe4482b311021a88912aed1d78e7748f6c971dcb713f013f5f0a815f62d9", - "8f4ae53930d528864d6bd7808d32c5c14828188014b20b2445a67dd605eba5cd", - "dca8d544dbba450d9f9d3850d12f04ed3b7a0d9ad34d927a1a0debf359ccbce2", - "118b0ee8c095f37e08b4ab2a90714438eb3e117cc4dd089cd38272bdc3c07bdf", - "033b85512e8c09b4585764284e5adf164552417a9ad3d555d8e86a2674977c5b", - "74ac9e28c971a5e85f53fb92796f6ecbc7c0b53fa66f0f386f5a580a2223a8d1", - "ec85ebd686ef0be5eaff07adda00d99079d499e5d8ea6fa6109e2e3c6ac952f8", - "5fdbde70666870dc3254a7af099490f89e6a1c8568e8874c2088c037b06b4c10", - "9a9e9020b919bfe76fd84a2259c1456b7cc898b05af56fe3b7602d9b3c2bdeec", - "1dadd9c7b2bcbba8618ae82efa38dfea06d448ec215e4d5474c8d0c1416b9d87", - "31ad5dd925942673e7172087f5098de93ada8e110153df8dba416dcfe8a5ba93", - "2c905f2acd27f903dd2e8b472acc95591dec08822365f0601cbff88635fb06ea", - "45969a505222444f053eb9b02c62eea133be32ca0a63d01b28614060422b3911", - "3ac0a148fb1592b5a7b566939fc4588f9c0da098c601f6aeab3f933b9cef4e98", - "72980a3c39a6abc62b1d4e9702f02ccc473d29fcedb076664d4ea7b455b952cf", - "3583b919fdf433c1a1aa44849a3eeaf47a98eef546b6c0dbf75938c0ee60ea05", - "802afa4c01fea455ba593b54021f1c18c5c7e262c32365d888972ac1a0e20fa8", - "049b57a16e45f5c0485fbd4b57f34341e55e5f7e00f314eca61bda0780ed9b59", - "3efe9327a4d9b7b74cbca06d7c704dbffd499a7aaf81130b8c2a03ea117c2d19", - "722620f97f062ef8451ff84583174f1523fd0feeb3cb6c673e7ffe8b26bc9c8a", - "d5e69f7288e56c05b67ae84e927c37acdc650412a694f5a67acc5a8fc22d27d8", - "ba7ddaf72f0e034da39b43276b9f418894a12a6fffdbcf6359a302ef1b34688e", - "5b65aebda07711f3b75a7e893258b7ad2d99d8107379e798fe78088b5041690d", - "9c5554433c25d0d360bece8bc3bb9223fc87380efc49b7e95cbda1ed6428d0f1", - "6ae31d5c26d707204d4d5afc3d4b17e01f0ba880da52b2be3ad6814b71f0897b", - "1de6d1daa1201e3c144b287d8f68b33747f8adf370969d1ef4b782120ca7e0bb", - "101548b62c2977f72e24b4fab110c3a956f09033e0aaca397db9f88e9f9560a4", - "5b39948a15013bbba67623e5da66dd0a15297c7d3e5adbc014c0c2a2892997d8", - "129d10b8724ba2b31a1044dd610ce85eab45798ebd7351f04fd05e2e997e4472", - "75b669a54b61a92f39d714aa02f64402a17870601b9b8eba29547d9b9e535d9e", - "c4557744f0b79b5a1747199f2b136eea2e2a8fb20f846dd064f5b0527be2914a", - "a088a61d157c11d9a228434ff6dc65ea28b3f950e75cdd6ad74e601333fb0477", - "44de5a4e2919c710639a388a185bff622b81595b8d62e874560c5f266082bdcd", - "c411bbe50d966a419fc8fd04327f1bbf6e37dccb12d6a38a635bfa8840787ad4", - "fe1f09ab7acdbddd0d62904a8a9ca18fa7e683d634e2bdf52245f700c7e817ec", - "7fe87ac755bcc31acacae4cc2cd3d48e1fe758df23ac23aa3b7b2560f6ecfb24", - "82537f27478a93b7da39b997061db33c8cc2de0f4352b9236708a02b2f9b84b3", - "a33d582c6d30bff71174fbb15c2296726b47110512390572b55c40dfc075859a", - "a2afb4a5dcb8358d706151ba7d93541ca313849cef7b20ab326f03aa508437e5", - "73a1ef159fffef5fc86e1b495251fb6c389d81bcc7c8b654640e23a042f60a01", - "35020eff0465c3451f0fe001372cf28508b26fc1494982edaa86f5ea1f2d8e8c", - "f7e466d813818f5d58d8f36ec32549b2f4e2e426332b74aac155a1c7e64e152e", - "daca2da778735d6c998fbafab0580867cb0ade2edc54cdeb264f5da5d7897221", - "b85f0ee8c73d1ba854550e337fc0366e30832033920407ae102ec5b6d748e16c", - "b9423049f0c08a96b4fdfaf264a2715fc8a20535a1a13e30d1c6fb2d7ba3aa48", - "810f634e5e9ce2aefc4a9c2b677deed287a18177d45709a92124c1dfc21c9c08", - "32c29482faf42f5516c22a8f1cf6c32ff786c9737cb483756efa3047ed84568f", - "15440dd1ee8c6405502efce469602aa85bd84441791aea9281d94e2c09303166", - "5b7fc2aa2037cb071169da797966392053280ea57f8b5a47477a2261d7e36d8c", - "7fcb9c56f281681c3f2639cb8cdc4932496366663f05718ba84bf28242db55d5", - "5785a503e32947a2d57cca46c81d050bd96f5e161f6b3fa22f257a6b63ffea2d", - "083cf10fc69620b2c9b6fc87b3fa951270812730af51d41a76c26a3d94f3a454", - "407d3d8ab6c58d2db63f3c496cac5efc4c426bc0aabd21e4e088932dd0c8aa0e", - "71aa71213ba2368f91cfc7fda9a21422827bca74e645709db17cd3e211891c86", - "4eb399f1f844564bae1a4e2a227caa4b279c4eff7e98f9329b07fc8df32671af", - "5f77d90bc8918f2ef60ccb4704f88042e844a6fdac00ea04ae69f68f8639f204", - "0a774c4e2beba82459bf3fe4af06df6b1bf7b357cf0228a165b5ee9a875c6187", - "407106e868c56cc888069b941f445955f0176f66c5c7d1581095cc0fd3c21cfd", - "3f6816990d768e729ea9ede1e9fdbb5e9127ca8cdbf63ea12c8998246129a1c1", - "fba0a480a4335d5e92153ff7d03e9ffe46a9e4ef4bd54c9bdd13bd969ff2c969", - "e271b513347dea314bbd0aa9678bb186af2cd5f795ebe88f1302514a5b5c3f97", - "63107e5c9e2ee927431bc9f338f242ea41c311eca08e79e577526b1bc2731184", - "ed13aa7b4873ef380b42b46320b3faa047980e2866696e2413ab30bfa60e7214", - "6da92b1b6fc135a6904c71c00dcb956617b5e171ce98e7b4ec0d1a2dd37c2fb0", - "d1a642e9c190e73917e7cbc268988f556779078cf561a5517766f84474ee7822", - "28dc26e51364fd1adede4f774332910ec4bd8993ff357923a7a0a017dfb97f9e", - "9a2278eea4d1cce0722bccf6224075a8f907357853fecfc9934eb0f6fc233e1b", - "8dee52edc49245a60a520c1a52ba1a3f0cf31ce315fee3503d443ad8dfc3227d", - "67ca7371b3c5de7313a39c94a2f8d151417ea34817b982d71d4326dc3e234641", - "e9611454c885dcda36186af633052f8f35756c6782b987132a80b873a6fa492a", - "1263e41f4484ee5f92d27601dcf5f4290e3aac3bded971d3e50d07d89425bc42", - "78f4ab6f4c7bfeafa592ea2e2916438fdf21e11990ee505e99d6feac858c419d", - "f253da602210b0fc28362f017473f23378f36d190d4ec9e9cf105c54e43d1c9a", - "647c20162d2db325ebf8e71cdaa0d7c06e01198d0b23581a228ac4d216e1665d", - "920603364021701350a2708ef788396c79d2e2b7ae48519bad2b09beac27fbbc", - "7537ba60fd0462809ced9a559fc5c3b59f444113a25370050f7023a4d7114525", - "6b613959782aab3c2f65b8dbb47aae388e7115bd2e2b59de362090c048082de6", - "cf78f7cd9e14692b92dbf6bfad5c67168b8ab53d1e358b2120b333eb233df1d8", - "b55a4dca50649fd4e4dee58b5b250f8768fe19d43804f5da1a3b6c995c8c902a", - "f10f2bb9ee6a70ae8d7f562c878c186e2218a04f2779c2ac54109c081d16daaa", - "f7cd919b5d35d35d430e9d1536105da9c082dc8a952811536b330a4d4ac1a260", - "a6541ef468449e3c05e199351cecb17c3e2c6bbf754de21005bb2ec7df175676", - "0a9385a59f86d47ffbd5eca28f613b8506cfc68dce29ca9dd0533fa96fb759bc", - "c359f7ed5e4a168b1e27bd1c27dc9752980103a2e1b38991e5011a7ea44d214e", - "da696073966e5f987e38c54c8117a921077c2bf26faa2c5207fe65bbcd61fd9b", - "89df9b912480e6c8a096cbf9e86a706bf1857a794431a9970f2c4043343b22fe", - "e4d56b83ba333a48e07d0fb82ce5c951e84a36e17bde670f49bba7e8f76deffb", - "93caf967eb5be0e7700fbec9176be10f6d09f64af8c32b691d1740c247f08269", - "f32980bf904020cd42532d2c16795204fd4edff4db3567e207bb8e23b26c1d52", - "54ca39f054af2c455174e4f9e8c85786e916c394f4edd1038aa2e28a0bcad171", - "1127ee833c972f00c1a9d1b005b725c4d99b0c67de5945c03f1f724a7db43780", - "bbb729809356522febd6a58d7c951f31bb900370b19c7f5a0fd69c1f122d1f6c", - "028d1efb0088ce31af4e2cc67bba0197cba4a0010d0e37f79ccb66d7f2d4982b", - "10307866ab7eded36b64fa736df25061fa5ea5ab743030691a9d50ebd29a71c4", - "f05f2de80509241f391f0556314376dcf5691cb6527d422e91c7eff411181d8e", - "bae982a385e4c5d64d94b3f52fb7f279dd412aafcda0af957d2f0060d60c531a", - "05321f995ba2cfd80d2ef978c9a07ae9f25e419556dde704354d797d6c53ad75", - "01f33b60ec0dd00b4e21ad4922ab300a660897ac8f728da6ea63afc145967446", - "345f259fd8e308a92e94b7b6c9f029fea1266470ba9ea6311eea519f18ddb65f", - "43c032e89cca4d98bdb51b8206ae27a907e47d97474ca89796dc919e392c8000", - "bfdbb6a414cb73486112a52a27a339279da4fbebd6fea64fff5666d8fa499b25", - "b6f174a9cd90b6ca4df4b00144fa7ceb37bd7bb5525e29083a77f02988e93cfa", - "31783102351f5d1c9e94c643b70ed6846259c3f75c401df9340453115840bbda", - "6225f386d6bf5a43e0552122cb01a3105b1d350b088dd9ce22582308cf05cb74", - "51c0642604fb7736168fac0bf66723529dfd08bad84d1495d96bc34c74df5c78", - "35a83108882fec52a6ca1424e81650ffff8cee65becbb68a1272fa0a508becfc", - "7428b0af8a33dd6a8c825dafccb48f1de992925bd119af569879c3e559d91035", - "7e7fda79ad0da1ad6be3995396417139fe3e7bf47850d13cbae39032b9df0af5", - "5d010b20bf9371bc10ddbfedb9a043510398c304428052004a52237e8c3bc04f", - "1d52d3e883078b887ee53a3ca435b0ad8bb1c69657eab441f7452ead603c3459", - "3ab0771f44260bd18e305595868691d923674b15760a449b00eae527b638ebf5", - "ae6eb20d4b1724d917356b69ade9b1ea8fc70968e753f95476c9b3851714f8aa", - "847912ad37a6012e986ffbfdf0d807aea66f46530e89fd469ac82fcf74cc518c", - "4fc17a34bec82d3ae2783decfc5c03e13be631a45f86306a38ec11e43082f2c5", - "10988e08ae7beac5d25a75a81afa670aa51ae8eb01d66a0bef5c94772d573cae", - "6ad7285cb09fa2f9ab40a7f1fbcf26942d0867d473788d5657bbcabb7fd7efaa", - "5c0dbf72df4ac137228f9d139d83f59405ea936788fee2b2306bd08a6b3e5dda", - "aa06843bee81526134f69dbef54a25d92cbe5c9b504bfa705bfe1f703efb5d56", - "e90f06b97533da5d4d2f262266a9d2e25cd4d1cb5993697a2ec8da6281482fe0", - "edc7bbd0169ecf6d3771451a71926fc16db27468791eda3d7f310378c3bfee3a", - "eca228cc9aa1ba55cd28988bbc531f6a26148b1c8ef9700e113c069e2ee93892", - "c5fb85376bfe9eab1eae1f407393877ccfd484a51d24f62378a020a8ddf6bf2e", - "610c10097207e5ab761b4296a975518947fdbb454f0e4ef1296d98c7539d41c5", - "a465b19b5306507e98180afaaead5af1fa13917a911a5f307576307d0c35707a", - "f97912e1595c55ff39ea3acf27e04a827f930ab9ce8061e3b72c533466ec8d6f", - "2ede1274799fdfb6b6bf1cf8f51681c08e99436b5f12a1da463d6fbbb9b47d69", - "108ee235def7b885c5b8e85442022bfeafa4019d10ff4af36dab0d1449e53cc3", - "264c4202708db1774a54c377382cb48929be8a8d658c4d790ffcde85d2799a21", - "a02b9f1af9a2009a5754fee7f82277e016c787814b8a5f8641864085ccceb4f9", - "a145c513fb4f0c033389bdc165cd07b387297169cfc054e17957d4c39ad615e9", - "abe0268291b2661b5744cfaa29d58f60bbf8ccbf1279b334e008827dd5f8a40d", - "3341ef488771c2804dbd9b5acad462cf453cbdcad867fed39c8c3d7db800f7df", - "44fc7f0798df5bffb199883fd0d2dc7f4013dcfce236087318d5716872200691", - "24f902ae7fc59e7331ebf94fc8312ce65d7a845fd89aa5ff602d0798988e61a4", - "f5d3fdfb2400deb0cb097fec90922423b474832dfc2c43f5b7116abc814e37ba", - "6c9a97615435947331d830ffc4c5198528003c9948707c604daca57829a3f2f7", - "75dcb222c0a503df9a8af953fc8e813803544e863e516e9b086db8e39a4456b5", - "1e7727ac7859e20a72e913cf4835f4096c09ac0772bd5ede3e84334c164523b7", - "aa811238156b0273029d2e63471770c35cc47193fe3f7b4f753995aecfb06b4a", - "f3a03b2a1c2174ccdca48b2adda9b60b1c696a898a0cb212c1f1eaa8fb53df71", - "855ae81572b1ec00269fb9ebe9e06feaca58a74a1aff5f2e626b60785cd13c35", - "f28d6b9e51908c546ed5ce3103183164bb53ae95a5ac153bfdc623778fb01155", - "2273ce151ce886df6dfe304109eacde8e3bea82e42e2b0e7cb9bf35481efcaab", - "15051e762dab774e7d1a6f0f30698f932b2c635565c55b5d68efeb675f725c21", - "d9d7e941c3f1fd68b6f6cc5e7e442aeb169010fc561b912597675b4c82f33b32", - "2b818e3d05c926f3acedf53ba1a020eb6c120f101da458b0b502eefb54170115", - "60b819d14f8faf5fb8f0557f9ccbcc48e7458df995d10ef0b92e8e174c313e01", - "c590e6b09bc2956e38a9eabbeda0c39eb10534f18519b103451f35641abe5656", - "53169004e6424b9769a498ed8b4c61dfaa809baa26e7d6ebe0fe014af99c4770", - "3b9084cf23e63bc5c8b936f7e97d8d840d8cc1112bc623fd4bb0721df796b67c", - "3d89c38efa3d10019fe8ca062161e88d572d56423d350529c01252e0be50bb41", - "441926a4665948dbd3df7acf44a4cd1fa5c6e3bcf3586843ec789c3a5988266a", - "30a76151dd3e2de0b82055d7ed05e7a37cc8d3608e2f858bbfc0c76edb306a78", - "e6d3761e3b6bc3367035a20f4d03e6645f4c33aade0f9ead6f6b504bce243ea7", - "77f1ef7f4ea1ce5e2be0b489556a343e431df5c1ff54022e1cf5e3be75f36487", - "e3ca39feba58d201a78af3756b5f6c3a849161caee36e3ccf14cc473459e8d0f", - "716c4c76867143759e8c45ed2c1e53e10ff79824185f3617902e78958b78695c", - "91f34d3be5bf4b9fb0cbf52a6565e4d1a5145533116c92c060b36de35635376e", - "407f589731122088f8cb7a170c6ac090c93e14a4a7ce9d460d7881096306a473", - "f1e8db4b26bad99ead041b7e9d5e2f36fe708ed83dc754f4aa74c08077334be5", - "bd343ab972a1bfc4de4cc9338c6b8fa246f996bc683d1c46ae801704eace6f59", - "3ba0117ac10d1bb951ee689f3b1d09c40d1686eed462d1b04839ca49f64b5c96", - "44e2e1b0e9a284ab0469f130e6eaac49632e591b1b00a9a37b6c931eed0c474f", - "489cdf50880e4d5fc254635d3211c627257e3d2613f426353ef54775669c4dbe", - "12a47c6d3dedbb86cff747adcb090026e4b772396f8d58ab6566768967813b0f", - "8492123394ce74946ab0a7b5b02280fe2364985e3ecf1d6b67f1c3541363305d", - "78e84d283f4f661b7a5f17c41d9571b0467189cc9c1218595f8a604b12a197e0", - "5a69a1aaf348618d5552e167819ed8ac9918191f68981c1c479d2d23f35aef26", - "3ad799126520722346d2098ce8c3551c1402a553cc3ab1fbfa7dda4c2083f58e", - "bd05c86769cd3c6301624e43c573190148da4e289808a9197e4dc84adcfc2178", - "cba04afe1491bff2f9159cc15441b48170096ef4339e52d60e4e901b17141031", - "8d2604b456e29757844f332d67e4cde6bf7b65f16fa0a4fedd6c3faee95a2a68", - "427a65e03a3d0470236ce6f4fb7657a71bc4f161954b55fb9d38685aee43dabc", - "18583b7ce1ffdd6152d9c33df40e2088faae349245dfb33252e49ddb219c6251", - "deefd800abafd099f9a0369ccdbac62d63edd1eea8c9cbdb47f7cb699d5379af", - "64de571f96048203140e04812e8590af18d83a36c931bf1685c89f313a4810ed", - "6f9869e9c729060fce8fe50891b731f028c6fdcba1e67256c511178d949064d9", - "9bed84e0188bcdf9fa0093bc18baac140f796e86781e2881c8ba83a38820f346", - "f6fcce77f0cbcbbccbce5f5d1fff74b3602454d372a210b7798a060a64407404", - "a860dca50450a563db74bcfc55ee0970640442bf2630af5b89850ae1edc5ed80", - "3ae0df3391fe1c0dfed2d75196309c440c8dae53de0820fdc4e17c0f9792322b", - "caee102ca96be4fca636a166fe18a43b4d51dcc2378092fe89aab8aac340de13", - "16a82b3fe100c84f26ae79f7effcad3c724a76415bd9a23290dc7978f1f3446d", - "21120542290ad8b32e700c9adb6182266dcc55f69bc037875b24d358083463a7", - "acc70578c3f6e8048daf021329222978bd5b41015317e84d8085a163a1f5a523", - "b32c7edf817d4a9e3742c89f76640446630b36f4487b842a304ba6f6f813f5ab", - "aa79e1d85dbde840090f7a8cbd25e60ada36012e87d18353c1e52ecf00e7fa5e", - "06613f0de853122abd644a4c3dbee1773404d40d498a6d0491878affc4f7a454", - "449dd10d24d404e36d1e530acb14883fddab84a335a3b276d487697bda89f94e", - "1128ef14328b6685b0343a90082536c980391e6c3a8594cba2d76d2ba95364b4", - "903bdebe295ee2070c2b45c56529c4cecfbcfd85d8af62e652e4417443a857be", - "21a685d80b5abb56473226d40353eb72e879d0b33970ea4abce8275b7b7e9970", - "d845667b8654f3116e4c6060eb933fa691bb3f7e65b2ca0081ca06e9c965b3ea", - "8f1c1421eb33f41d8067870e1566515d99469cd52df65b7a5c38bb197c3e0c36", - "153057975cc119ba141788e324f7a52338e3d36407ee07afdde53839743dbf9a", - "85ebdf3ad8ac683839ca3d26ab8c63685e19d1af0ec8dda452a9f6240d812d04", - "aafd8f6c7458e2a8f1c9f148c76c200b9a9b135337202cff5bb48ba9c917a7f0", - "cab6bc874e7d10139ede9054bb53fdd6565f19eb577893e6f4bb404d051543ec", - "1cb1f909176e3ab8e229b466c9e27468d57cd8e696b43284da856dc927d87ac2", - "3c74d9ce1c7e90dc761ff59b6ff4889c08c25cf859a933820e2c6778f3f87a01", - "18d01c53efefaaf795a7e49948af3430c766efa591339a373be6b794f1ad06e9", - "31bb82e1a9d8d81c1455e7b0a4e8d092339488c3c44a2f8ce0ea1bc7e7791dc9", - "580647ad8c108c412f99e16fd60fa0774f0f670d547f5b85bc3342bce9956825", - "6e3af4352050918838c0b8d4f18cd5f636d9e701a06b327287da96c874d42cc2", - "ab7cd65e86c5213cdf5f1fbd3b34b1d803d9d6141b1a5079633d962aeae5c0e5", - "535843fbf06751feba5ce8333db04f9358204171b4322ae2b4b5152ddf96c31e", - "1291df20ca229095ce11da54804a1eafab76a82178c2cc3976ff53f252ec61b0", - "c5a486466cb88fad9cc04f3ce3840b243493edcac08ea52759b5cb22e9079228", - "d190906c20d4fe2a9445617e3391e504b169438e98a7bf3ddf5547241f6c9ab3", - "ce70d0b0f95f815435804b18f084eb70630ef65b95663ffc019c8cf82e32fb31", - "8855373cd52bc76498cfb7fb3252cb73281ae66d1ef74db08abc154048b3ef37", - "af9f61f563341d54392a82249b3306c0af8e9e20d8216f55adc5e09a3608433e", - "7ccbc570c1e857ac0fa088ce6f6449661a6176a41051ba22261efc61df02f1c9", - "aff3cbf02de866336dd18c3223bbd79b15df92f4e2d232d38dc077eb940951ee", - "d1b23b78c916dc2d436617e11105e06aac9a960224c16788f56cb6263bd73b9a", - "8ce93a8135dffa7c1b62ce11af88cc796ca88f354b1393c2986325b32c8cbd1e", - "77b6a6ebd06cd965d6ee409ac1b9b3fde08d8074d22023277b3f389a89cf5ca8", - "634c38e8e105992862ec1b22d8d04be0c4b7235479dac76139e100770ad2a6d8", - "9c872c70ab302c00b016791a73876db8883fb84ba33573eb8a2668c14bac847a", - "60dca31ec81c69d2cf9278d5171928e4652f768701effec4addbd35c918c480e", - "ff80118317aac77149d766aa829217d18d719501dacad9488f8996edf571e076", - "55fff837eed4bc50b5276926cf2f0b8bf7b1d03ac681c323ce64fdb32f939b1d", - "83c8afb9bbbbcd2697827df9d4e140446f3a30f7814596f4a9ca6ceb23b2cbaf", - "fe986788cdba0a37ad646602197fecf6088d06a431145c82b62bed4ec73af7aa", - "26940fc99ce63c944f26fb40072a010776670bc5ce5a0c980982508cc1d8fa80", - "e5978cebedf2479f5418b7513bfe84971cdaec1a6da8f542ca96b73e29d7487f", - "9ef74c16e3184f55edc44fccf3b8b5a233aaa984308e0a0bce41699e7ea4a030", - "29779b4df1917a3622031d582130d0e270044d8536c743cbb32ac67d2623e297", - "424a5488bf25a262dbe74d0e7cb8b16a9f00e308bf454b87aedbace031aed016", - "e80b995c6cd62d576f3e70e746f7966a93c7a3dc5a4ffcccbdffae1eda80dfdb", - "e0fa251236b31126c28fe8b3b95fdfb8ffc590c67481f42e8263ab7e2b296d73", - "6a4617df8983276889ce6013e2f7fe3b1b0fc4d6f6a3167a0b3242f969067164", - "802551c1d13202ac6d8ba8d4eb33327cfed8ecb1b1fc71f2ae6a1a05d6631206", - "9fff47d5e452dbafd22ece05da70c4bf1b024092fefdbea2aa9443132118f318", - "7f1c92f8efbecc72ff5a1e1c5ec4870f4f9a852a7c5541b5779d20e4a2800cf4", - "dd7a849c1c1a0e75b884a529dc14b0dcccb96de3ee0c1854b883c6c891c227fa", - "cb8cc0deec4ae303338c4885448f0af085604996d61359534d46cda8dbe75abc", - "e261bbf46983b8a1b0f65b6f1f136f4aa40b04ba7944b8039de015d30b68bcdd", - "e60882aa61e6012981f29a5118b503b9d48dada4218f77e1ae57bf70dfa0900d", - "14c8d92f8aba3eb0c84c535e1d3e01d7a005baf7a9161ef085f2d2c37bba283e", - "4841f81014d2c936c1a63a3c43bf98e3ff015ee084056f26d1c1b8c71514ab96", - "d79d530b7bd2f0a3dc8f0c13c3e0c41ffe8992acbc74cd7640004cb6dae4ba71", - "2770f686921772a20d8a3e372fc2a3b1011ba64ecab7d10b9b7b7b08cd0fc53b", - "d618f38c0b2f73bb7985a1f07a7b4ca3b70e62a96407b8f6877da59e9241ba82", - "a42ade80310d49e8f0815265cab30124c93e6f0eb30d12bc031abd031a1fb63a", - "ed5f84568182e3084ebfa883e67706aa5cbc40da4e1f3b1ac31e83d199df1e28", - "fe65e104c6cbf94e45a3b7a4031835d60266b349c4822a5c428dd8165540a969", - "93d4bea4a2ff42c29ab39eb6d591c14fd0e256f276ae22236d1a91a0dcb02a69", - "aee3a3c773ab886688a170974b6a3fe083eda38cb3d01d9aa2b04bdce7888544", - "e953e0638778d54ceddb78235745ed4f91f5eb05d0d59c27dccc08c1ccc7267c", - "d42f1fadf8588fba6d538352cea0867a90439ca94a16e988bf3439631625e0ba", - "e328cc982fd207aa419ab2b289c4510d2e95a7988ceccf3fb816d722e271c684", - "515232154ec5ba324c8ca107ffd9f1519caeb8112b330146d96efd78715eb075", - "3f67af96b2fbd096c015c56e986365f34f3c48d8f48aa42ac0a3a148c81f64ea", - "4d2f1dd1870a1d86dacfa2a72ea18c2c3ab689eed9480466e4a1214f3806efaf", - "2c0be286b949750cb04a57f7ed1d40226c253dd3f5d9ae994544b570e0b10334", - "7056ec198469c9a1c4e93df4c201edf0ca977e076ee601a21fce725a3df985a7", - "dbe8fe7a451786d405f01a370f47d69dfde4c14d53fa204d2545e47559fe6d83", - "705f04d243a5a3c1ceff4e030c6060b8caed632f1c691f14cca7c8c997b03401", - "2e449ead7445d65e0de5698daca28fcebaa29b16547a034470fe0678e6d52e52", - "919ee6904e41ab8a170ec89f654575c036afb9d97ab7242efeeeb06cbd3d688d", - "4ca7f777f2773826eef93e84284a27b58d85beee44b51b3167c6419830417041", - "663942bc1b38516b5388701047626de6ccfa978622709b8c382897bec882025f", - "d713c67df8ee6c3b6d3cd3ecce25cf7e68867632460d315cd1cee2a69886c07c", - "cfc2d700513b0d60d68ad6ee90b4e8dc04e7c45a92b4de0550e2943d7241fee6", - "23bd8f99e8359f0052e16c65689eae80cb20bf937ea6ca5794d36d29734a560b", - "f7c9b3e29590943b38ff1b7fa5e8cb65e73d768907396029d5fe6855c963e9d9", - "f8603e835872e1c804ef8544b8a345f7bb4ff0925b11d3da1d6648cb045fbade", - "1ce486424691a31d6b5e9fcb755119f8b1d917c65dc176c5a275f92110238adc", - "b9ee08e5abdb5c4469854d67f816519506b3ad8d8aa50d09afac35e42f6ea73d", - "199a569d05cdacfe810f183d7f114f78f4412772259c99da391aa1eb4390a9dd", - "4757a77e3611659864043267aea61c38ebab2f02773047426aecac4307ede8a4", - "d7cafd282216b04e84cf8ba7c13d08561cd49bc7c6d816b8b691deb063359145", - "c7416c8c5c173649dc37170bb7d8b29e97ed5aa810c7355cf3b52c79fd05ca6e", - "90b722413415286b4a50ab758038e52955f35ea128fabc943de4068ba687744a", - "1d48f66f2d29c82d950a117863652bf9f8cb557c85ee5a49f585670acf8d45e5", - "c22abe9884d1b5debcf86852e9cb6a012ae605140b1e8db907b8abe0d9bee523", - "b9eb6ce364c57d0123cb7cb3a0f1df5c469f28134a0438566e9bdd601b8622f2", - "6750c50fb1c0d3eef8aa684540716bd6a98fd23669008551655b1c8de9a25708", - "361837e189aba374f1e02b095d702a0cc59a3ca4d0ebbfb3c9367e68a4ecff20", - "7b12e03e4bc28aae2d137dbe65e30ebfdd1f02dc4bc3001370f39b806650923e", - "0feef38c75d9d985086da61365e620ba0996a77fb420a087ea4635be7801433c", - "9f7e5b15f0a20a830325295284b9ce5c5f7f352ef6f83fdcbdec431aac375506", - "e9f329e53c0ace3dc96c87fad621b6aa921b78cee94e620b6655849aab05f473", - "783b81ac45016a986b3a45812776415794bc38172e339fc652f704220e560a53", - "ae2fc2ec3b3e5eebcbd9e26943a71af32dd803c550651da76c77ab8eb71a2657", - "3b06f17a332ce98611838bdc2aa2f0e8c512bf98a208bdbca5c97e01d5413dd6", - "90f34ce0bc43f3c084035550a3ce9926b395dac7fe5e9b895a2376d089e8578e", - "0878d24dd431ebd8ff4d0411925080d34faf64219c1e4f21eb9a25e050ef4361", - "f4f4c3cf74765eab1f5e06cf4088dd107b7ddf56e62d8f693485913f37ac8464", - "677a663f6bc1564b27a27de11d8c6adde8b00a26cd64449e60565c3c702fad14", - "927658d1379d4b4cbf2743832d8f0ff737d329111a66aceb5470d2b4d58dda19", - "d68794c3aae12835b0b7e786c492c396e0494b785e64da876609cd4a530acfb1", - "82ceb834db6a58732c8a9ffc41d6c98eae1b84a08e9546c77a88206944c9a5e2", - "b26bd6ba8057f52163faadf64da9b7a966ea79a3a19fcf91b7331bd5f3edab36", - "8c1ea0d5c45a72e2bef3a0667fa7287ddf9afa8b15d8eb802f99c8b8b96c6838", - "50df1852f527708a9fadf478d0bb069c6de39587e0462f564c0b2c7c5776380e", - "3d55838e868095eaebc0114ebfd6b83b2f3a3e449688b8a6c98dbc6c130c7673", - "f01018b246343a26556682745de76e3f4791daf8fb2eb1804e0db9c8fb9202d4", - "3845706012cf9987a31fb12f84fd74d83c6a6f55ba248037b11609c79be59241", - "8c275b2f773ec083b990f252af74e39652ceaa13d482cf6f7a78e0f0354271a2", - "2e6a71fdaf7784924271b8df00666dead9c304df746b0bbee03cc802f49894c4", - "cc37a5bde73bab90a0a46e091d7ab0d2fbbd4adc194d303dda2bcd06fe607033", - "0f1589512695d4601df108d2ba53b22724ac291dce84b77f56077fd7a8b2ec91", - "da259d4a634924a1d9c5b5362eab01c0dda5f7d055bbb80aa2fbfb8c0cb286e3", - "b3f05b6f7d26d0d46e5fa6864d1e2b3d297b50d6ab03202aad73bab6ed214771", - "9310695e560218fd67fc3e279ee7f54298b971545225fc98b6861575e0e73a92", - "0818d7a1d0982a89c0ac99c2572b43d53b2150fd3021879da5acf42a2df599b7", - "7bc91deb0c6a73a093464cb5880906dc06c41b499ce6636686b6949d881896fd", - "f58ea17bb1f306c74b1e0fc457bc0d6e50d9e82889d8f7f458c4355ea37b78d9", - "4d3d3943d686b6573fac81579627b2bd4e82c9bbacdd0fcc3013a327e7ae1acb", - "87f9cd52330d7d665e965fa855114fb1428bda09f545fa55d6c0db962db1eb07", - "ed15782ba049fd69920ca177a07991b8551a236135a216802eb04b6ad0047eab", - "9a350b62d69df224e9ce99fd30aeda586e68219216af65f8787ff9688b9da811", - "bd931b3508b339ccf5773f6825267c89cc633cc48081c3f953bf7c63df1889d0", - "24a6ea2f7c9f8aba532a9cad74bcc5fd813244303b803be705e1c6e375e4593b", - "7fa2aa064ff867a393d499fd3fe678734d824b7fabeeafe2e751b34f1cb9b4ac", - "32d0e8008df2ec86bd881c606c948b0b9a216e37926df6fce426bc75baa9340d", - "6c7d8c9e1c67f357f510bd66a9a752e1666fbbe32e9d3be3f1e3ac7193385194", - "3ff82e184d7029e4e6446aca43a383220a360ba80afa403d520ce280beb81b2d", - "f6276f20fa01e6c6c3dbb377ee7c4eb8053db53d3265d55cdcae7aa12d6eb41a", - "e3046964710fb1b63cf2ec35ba110bc2c8e1a2d1f4eb5ee05131b2af2fd2d5d7", - "da4fae100599eb9dfb9500f28dd604665eaba000cd4b94940f3471c85c8de99d", - "0457850705a0b96353d36ad642a5a81918383c9ec8586349e26158c6a4a0b7ae", - "c92e1a01af5e072b5460b47622679b0298a978ba3cda18dc910994434b8a073c", - "89329ac82483a5d974f7b853e22923e5405ffc6d81bab3c84a8beab932d48a71", - "ea88e9ed7e4fe4ae923c7f04481a53da0ad687197558107ee3cc957895666ee9", - "abd3d2574ad462216b5e08aabe09ef9c662e60b0d1618ae1c5999838a09a5983", - "cfa1833d6bc93aff43779c869dfcf8c8a0be4b5922d19609a26a2f7405127fc0", - "814676d70f7a19a0b6a635e78e581ac2a6740d132e3e87305f798ebc6dd10353", - "1bc1bfb1626066c2377316ba20ab796716a80017f85721aaab9be5fb50dc78e3", - "0b94d3821f6c4c1fb691b61d1910ffd3555febe18ba7f30a326dee2f8d826b23", - "2517525b80437b378c1c671c4b7c87ce0a3d9de78c702efd08e2bfebd8c3156a", - "c5696ed10d3fc01103a9f2aa79a96d6e42384a5739f93a2edb5167e9331c2a5e", - "1488580ec421ed37cd1e01e1cb067a07a98716edb604bc9daac35c25b9fb1a5e", - "dccb5c741bb39cbfb540785d1610fe40e868a05617084e017b0ff413b76e0fb8", - "688055d67c2315ff096cf39a0664941e8209d434323fabf8c695efc2974e604d", - "5e19e67c4d216c91ffc7987b5b39c69f016fb7628bfed1279286c9b8d782d209", - "21ef55154770a37c1fd401d309720c5b67d069471c20c9ba1e929fd87303be2e", - "ebdf7c3063e13561e419d4daadf1116ca855a5c82aa154c8985f75a9223f98b5", - "a89b8e9799a0a20efdc61aac5c7b1f87a3e9eccab65aabd5f09d504632f79692", - "c8c81a193cc3859af01dc4babe2b1cb8346bdeae00fd5fbb137e7b89558e3d79", - "84080310788c7f2c59e6c2ee986840f0bb19aeaa2341ae14abfa5c30a03a9cb3", - "d135d67a3fb1bdfd7b8a372b127509c43a06fe798ac1f3f6ce3a2a52aef2ccc5", - "012939599a15a0b9572591240b5a37a9ed7a19ad19e5428daf7fa860cfc97c07", - "c3112134af47da13c5567aae33fb0d24019c58b1dcf5a6a70bddfe31e67803c6", - "f218c07ab165cf2eedf6998386826b75e214442cdcdb89ad8f81373285177ce3", - "792db30c597fccb843faeae6da6cdc67f0162fde98957ce1d1677c7b6e706629", - "215dc82eaf68f0837e0ed33b89febc93109dbc0aadc42a4e540c55678e42c290", - "0f232bf37eabf090eb4fa2851a9cf5651bbcd59daa3f039ebd853988680be2b5", - "3e5cb386792b79fdaea2d738696bb31484540b65378f0407b7c8cbcf4d2aec15", - "7d42108aca0b382e7295f5075f9e10e7ce0b4a5178cb828a2b54716eb0f475f7" - ], - "jsonl": { - "path": "ultrafeedback_eval.jsonl", - "sha256": "2dc018ad45f13b2a4739cb42f3a137feb6d533f7cac6ebb32affd0277612a4df" - }, - "parquet": { - "path": "ultrafeedback_eval.parquet", - "sha256": "935b45178642c319ffab5acca16fd0fd814e42b683deb9683a32195121ef7f87" - } - } - } -}