Mirror of github.com/kouroshSA/ppiGPLM + MED4 ckpt_7e checkpoint and sidecar note

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/ppiGPLM.png filter=lfs diff=lfs merge=lfs -text
+assets/tri_model_consensus.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,34 @@
+# Model checkpoints (too large for GitHub)
+out/ckpt.pt
+*.pt
+# Released checkpoints under checkpoints/ are tracked (on Hugging Face)
+!checkpoints/*.pt
+!checkpoints/*.pth
+
+# Large data files
+data/*/input.txt
+data/*/input.csv
+data/*/train.bin
+data/*/val.bin
+data/*/*.csv
+
+# Large prompt files
+MED4-PPIs-low-confidence_ppiGPLM_cleaned2_prompts.csv
+MED4-PPIs-low-confidence_ppiGPLM_cleaned2_prompts.txt
+
+# Python cache
+__pycache__/
+*.pyc
+
+# Output files
+*_output.csv
+*_probabilities.csv
+*_classifications.txt
+LES_results*/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Wandb logs
+wandb/

LES-wrapper.md

@@ -0,0 +1,160 @@
+# LES-wrapper: Learning Efficiency Score Evaluation
+
+## Overview
+
+The **LES-wrapper** automates the evaluation of model trainability across multiple
+training checkpoints. It runs inference on PRS (Positive Reference Set) and RRS
+(Random Reference Set) datasets at each checkpoint, computes ROC metrics, and
+derives integrated learning efficiency scores.
+
+## What is LES?
+
+LES (Learning Efficiency Score) is defined as the **area under the metric-vs-iteration
+curve**. Unlike metrics that measure only final performance, LES captures the entire
+learning trajectory:
+
+- **LES-AUC**: Area under the AUC trajectory curve
+- **LES-F1**: Area under the Best-F1 trajectory curve
+- **LES-Threshold**: Area under the optimal-threshold trajectory curve
+
+Higher LES values indicate faster learning, better overall performance across training,
+and more efficient use of training iterations.
+
+## Workflow
+
+For each checkpoint the wrapper:
+
+1. Runs inference on PRS and RRS prompt files
+2. Extracts softmax probabilities for the positive class
+3. Combines probabilities into a single file for ROC analysis
+4. Computes AUC, Best-F1, and optimal threshold
+5. Generates a color-coded ROC curve plot
+6. Aggregates results into a summary table
+7. Plots metric trajectories across checkpoints
+8. Computes LES values for each metric
+
+## Installation
+
+```bash
+conda activate gpt
+pip install scikit-learn matplotlib numpy
+```
+
+## Basic Usage
+
+```bash
+python LES-wrapper.py \
+    --checkpoint_dir out_ppiGPLM_MED4 \
+    --prs_file MED4_Int_100pairs_prompts.txt \
+    --rrs_file MED4_100_RND_prompts.txt \
+    --output_dir LES_results_MED4 \
+    --vanilla
+```
+
+The `--vanilla` flag is required when evaluating standard ppiGPLM checkpoints
+(i.e., checkpoints trained with `train_.py` rather than a HOPE-variant trainer).
+
+## Common Patterns
+
+### Selecting Specific Checkpoints
+
+```bash
+# Only checkpoints at iterations 1000, 2000, and 5000
+python LES-wrapper.py \
+    --checkpoint_dir out_ppiGPLM_MED4 \
+    --prs_file prs.txt \
+    --rrs_file rrs.txt \
+    --output_dir results \
+    --checkpoint_pattern "ckpt_[125]000.pt" \
+    --vanilla
+
+# Every 5000 iterations
+python LES-wrapper.py \
+    --checkpoint_dir out_ppiGPLM_MED4 \
+    --prs_file prs.txt \
+    --rrs_file rrs.txt \
+    --output_dir results \
+    --checkpoint_pattern "ckpt_*000.pt" \
+    --vanilla
+```
+
+### Skipping Inference (Re-computing Metrics Only)
+
+If you have already run inference and just want to recompute metrics or plots:
+
+```bash
+python LES-wrapper.py \
+    --checkpoint_dir out_ppiGPLM_MED4 \
+    --prs_file MED4_Int_100pairs_prompts.txt \
+    --rrs_file MED4_100_RND_prompts.txt \
+    --output_dir LES_results_MED4 \
+    --skip_inference \
+    --vanilla
+```
+
+### Plot Customization
+
+Use `--no_plots` to skip trajectory figure generation when you only need the
+summary CSV.
+
+## Command-Line Arguments (Vanilla Flags)
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| `--checkpoint_dir` | *(required)* | Directory containing checkpoint files (`ckpt_*.pt`) |
+| `--prs_file` | *(required)* | Path to Positive Reference Set prompts file |
+| `--rrs_file` | *(required)* | Path to Random Reference Set prompts file |
+| `--output_dir` | `LES_results` | Directory for all output files |
+| `--checkpoint_pattern` | `ckpt_*.pt` | Glob pattern to select checkpoints |
+| `--include_final` | False | Also evaluate `ckpt.pt` (the final checkpoint) |
+| `--no_plots` | False | Skip generating trajectory plots |
+| `--skip_inference` | False | Skip inference; reuse existing probability files |
+| `--vanilla` | False | Use standard GPT checkpoint format (required for ppiGPLM) |
+
+## Output Structure
+
+```
+LES_results/
+├── ckpt_1000/
+│   ├── PRS_iter1000_probabilities.csv
+│   ├── PRS_iter1000_classifications.txt
+│   ├── RRS_iter1000_probabilities.csv
+│   ├── RRS_iter1000_classifications.txt
+│   ├── combined_probabilities_iter1000.csv
+│   ├── ROC_iter1000.png
+│   └── inference_log.md
+├── ckpt_2000/ ...
+├── trajectory_AUC.png
+├── trajectory_F1.png
+├── trajectory_Threshold.png
+├── trajectory_combined.png
+├── summary_table.csv
+└── manifest.json
+```
+
+`summary_table.csv` contains per-checkpoint metrics plus a final row with the
+integrated LES values. `manifest.json` records complete run metadata.
+
+---
+
+## Appendix: HOPE/Titan Checkpoint Support (not used for vanilla ppiGPLM)
+
+The script also supports checkpoints from HOPE/Titan-variant trainers. These flags
+are no-ops when `--vanilla` is passed, so they do not affect standard ppiGPLM runs.
+
+| Flag | Description |
+|------|-------------|
+| `--use_titan_in_forward` | Override Titan memory-in-forward flag (-1 = use checkpoint value) |
+| `--enable_surprise_updates` | Enable Titan surprise-based memory updates (0/1) |
+| `--surprise_update_in_eval` | Allow memory updates during evaluation (0/1) |
+| `--adapt_mode` | Prefix-adaptation mode: `none` or `prefix` |
+| `--adapt_steps` | Number of adaptation steps or teaching epochs |
+| `--memory_state_in` | Path to a saved memory-only state file |
+| `--teach_file` | CSV of supervised teaching pairs for pre-evaluation conditioning |
+| `--teach_delim` | Delimiter for the teaching CSV (default `\|`) |
+| `--teach_has_header` | Whether the teaching CSV has a header row (0/1) |
+| `--teach_reset_policy` | Memory reset policy during teaching: `pair`, `file`, or `none` |
+| `--teach_shuffle` | Shuffle teaching examples each epoch (0/1) |
+| `--teach_max_rows` | Limit teaching rows; 0 = use all |
+
+These flags are relevant to the HOPE project (if/when it has its own public repo).

LES-wrapper.py

@@ -0,0 +1,662 @@
+#!/usr/bin/env python
+"""
+LES-wrapper.py — Learning Efficiency Score evaluation across training checkpoints.
+
+Runs inference on PRS (Positive Reference Set) and RRS (Random Reference Set)
+prompts at every saved checkpoint in a directory, computes ROC-AUC, optimal-F1
+threshold, and Best-F1 at each checkpoint, then integrates these into a single
+Learning Efficiency Score (LES) per metric — the area under the
+metric-vs-iteration curve.
+
+Note: This script supports both vanilla GPT checkpoints (use --vanilla) and
+HOPE/Titan checkpoints (the --use_titan_in_forward, --enable_surprise_updates,
+--adapt_mode, --teach_* flags). When evaluating ppiGPLM models, use --vanilla;
+the HOPE-specific flags are no-ops for vanilla checkpoints.
+
+Basic usage:
+    python LES-wrapper.py \\
+        --checkpoint_dir <dir> \\
+        --prs_file <prs.txt> \\
+        --rrs_file <rrs.txt> \\
+        --output_dir <out> \\
+        --vanilla
+"""
+
+import os
+import sys
+import re
+import glob
+import argparse
+import subprocess
+import csv
+import json
+from datetime import datetime
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_curve, auc, f1_score
+
+# -----------------------------------------------------------------------------
+# Parse command-line arguments
+# -----------------------------------------------------------------------------
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='LES-wrapper: Learning Efficiency Score evaluation across checkpoints',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python LES-wrapper.py --checkpoint_dir out-model --prs_file prs.txt --rrs_file rrs.txt --output_dir results
+  python LES-wrapper.py --checkpoint_dir out-model --prs_file prs.txt --rrs_file rrs.txt --use_titan_in_forward=1
+        """
+    )
+
+    # Required arguments
+    parser.add_argument('--checkpoint_dir', type=str, required=True,
+                        help='Directory containing model checkpoints (ckpt_*.pt files)')
+    parser.add_argument('--prs_file', type=str, required=True,
+                        help='Path to Positive Reference Set prompts file')
+    parser.add_argument('--rrs_file', type=str, required=True,
+                        help='Path to Random Reference Set prompts file')
+
+    # Output configuration
+    parser.add_argument('--output_dir', type=str, default='LES_results',
+                        help='Directory to save all outputs (default: LES_results)')
+
+    # Checkpoint pattern
+    parser.add_argument('--checkpoint_pattern', type=str, default='ckpt_*.pt',
+                        help='Pattern to match checkpoint files (default: ckpt_*.pt)')
+
+    # Include final checkpoint
+    parser.add_argument('--include_final', action='store_true',
+                        help='Also include ckpt.pt (final checkpoint) if present')
+
+    # Titan/HOPE arguments (passed to sample script)
+    parser.add_argument('--use_titan_in_forward', type=int, default=-1,
+                        help='Override use_titan_in_forward (-1=use checkpoint value)')
+    parser.add_argument('--enable_surprise_updates', type=int, default=0,
+                        help='Enable Titan surprise updates (0/1)')
+    parser.add_argument('--surprise_update_in_eval', type=int, default=0,
+                        help='Allow memory updates during eval (0/1)')
+    parser.add_argument('--adapt_mode', type=str, default='none',
+                        choices=['none', 'prefix'], help='Adaptation mode')
+    parser.add_argument('--adapt_steps', type=int, default=0,
+                        help='Number of adaptation steps (0=disabled). When --teach_file is provided, this means teaching epochs.')
+
+    # Memory state
+    parser.add_argument('--memory_state_in', type=str, default='',
+                        help='Path to load memory-only state file')
+
+    # Teaching file arguments
+    parser.add_argument('--teach_file', type=str, default='',
+                        help='Path to teaching CSV file for supervised adaptation')
+    parser.add_argument('--teach_delim', type=str, default='|',
+                        help='Delimiter for teaching CSV (default: |)')
+    parser.add_argument('--teach_has_header', type=int, default=1,
+                        help='Whether teaching CSV has header row (default: 1)')
+    parser.add_argument('--teach_reset_policy', type=str, default='pair',
+                        choices=['pair', 'file', 'none'],
+                        help='Memory reset policy during teaching')
+    parser.add_argument('--teach_shuffle', type=int, default=1,
+                        help='Shuffle teaching examples each epoch (default: 1)')
+    parser.add_argument('--teach_max_rows', type=int, default=0,
+                        help='Limit number of teaching rows loaded (0=all)')
+
+    # Parallel processing
+    parser.add_argument('--skip_inference', action='store_true',
+                        help='Skip inference step (use existing probability files)')
+
+    # Plotting options
+    parser.add_argument('--no_plots', action='store_true',
+                        help='Skip generating trajectory plots')
+
+    # Vanilla mode (use standard GPT model without HOPE features)
+    parser.add_argument('--vanilla', action='store_true',
+                        help='Use vanilla GPT model (no HOPE/CMS/Titan features)')
+
+    return parser.parse_known_args()
+
+# -----------------------------------------------------------------------------
+# Helper functions
+# -----------------------------------------------------------------------------
+def extract_iteration_from_checkpoint(ckpt_name):
+    """Extract iteration number from checkpoint filename."""
+    # Match patterns like ckpt_1000.pt, ckpt_iter_1000.pt, etc.
+    match = re.search(r'ckpt_?(?:iter_)?(\d+)\.pt$', ckpt_name)
+    if match:
+        return int(match.group(1))
+    # For ckpt.pt (final), return a large number
+    if ckpt_name == 'ckpt.pt':
+        return float('inf')
+    return None
+
+def get_checkpoints(checkpoint_dir, pattern, include_final=False):
+    """Get sorted list of checkpoint files with their iterations."""
+    ckpt_files = glob.glob(os.path.join(checkpoint_dir, pattern))
+
+    if include_final:
+        final_ckpt = os.path.join(checkpoint_dir, 'ckpt.pt')
+        if os.path.exists(final_ckpt) and final_ckpt not in ckpt_files:
+            ckpt_files.append(final_ckpt)
+
+    checkpoints = []
+    for ckpt_path in ckpt_files:
+        ckpt_name = os.path.basename(ckpt_path)
+        iteration = extract_iteration_from_checkpoint(ckpt_name)
+        if iteration is not None:
+            checkpoints.append((ckpt_name, iteration, ckpt_path))
+
+    # Sort by iteration
+    checkpoints.sort(key=lambda x: x[1])
+    return checkpoints
+
+def run_inference(sample_script, model_dir, ckpt_name, input_file, output_dir,
+                  output_prefix, extra_args, vanilla=False):
+    """Run inference using the sample script.
+
+    Both vanilla and HOPE models use the same sample script (sample_fasta3.3_softmax_error_handling3e_hope_v3.py)
+    since models trained with train_hope_v3.py --vanilla use the same checkpoint format.
+    The vanilla flag just controls whether HOPE-specific args are passed.
+    """
+    cmd = [
+        sys.executable, sample_script,
+        '--input_file', input_file,
+        '--output_dir', output_dir,
+        '--output_prefix', output_prefix,
+        '--model_dir', model_dir,
+        '--ckpt_name', ckpt_name,
+    ] + extra_args
+
+    print(f"  Running: {' '.join(cmd[:8])}...")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f"  ERROR: Inference failed for {ckpt_name}")
+        print(f"  stderr: {result.stderr[:500]}")
+        return False
+
+    return True
+
+def extract_probabilities_from_csv(csv_path):
+    """Extract probability of '1' from inference output CSV.
+
+    Note: The prompts may contain commas (e.g., '<ps1>,SEQ,<ps2>,SEQ,<')
+    so the probability columns are at the end of each row, not at fixed positions.
+    The format is: Prompt, Probability_of_1, Probability_of_0
+    But due to commas in prompts, probabilities are in columns [-2] and [-1].
+    """
+    probabilities = []
+    if not os.path.exists(csv_path):
+        print(f"  WARNING: File not found: {csv_path}")
+        return probabilities
+
+    with open(csv_path, 'r') as f:
+        reader = csv.reader(f)
+        header = next(reader, None)  # Skip header
+        for row in reader:
+            if len(row) >= 2:
+                # Probabilities are at the END of the row due to commas in prompts
+                # Second-to-last column is Probability_of_1
+                try:
+                    prob_1 = float(row[-2])  # Use negative indexing to get 2nd from end
+                    probabilities.append(prob_1)
+                except (ValueError, IndexError):
+                    continue
+    return probabilities
+
+def combine_probabilities(prs_probs, rrs_probs, output_path):
+    """Combine PRS and RRS probabilities into a single CSV for ROC analysis."""
+    max_len = max(len(prs_probs), len(rrs_probs))
+
+    with open(output_path, 'w', newline='') as f:
+        writer = csv.writer(f)
+        # No header - roc.py expects raw values
+        for i in range(max_len):
+            prs_val = prs_probs[i] if i < len(prs_probs) else ''
+            rrs_val = rrs_probs[i] if i < len(rrs_probs) else ''
+            writer.writerow([prs_val, rrs_val])
+
+    return output_path
+
+def run_roc_analysis_internal(combined_csv_path, output_plot_path):
+    """Run ROC analysis and return metrics (internal implementation)."""
+    # Read probabilities
+    prs_probs = []
+    rrs_probs = []
+
+    with open(combined_csv_path, 'r') as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if len(row) >= 2:
+                prs_val = row[0].strip()
+                rrs_val = row[1].strip()
+                if prs_val:
+                    prs_probs.append(float(prs_val))
+                if rrs_val:
+                    rrs_probs.append(float(rrs_val))
+
+    if not prs_probs or not rrs_probs:
+        return None, None, None
+
+    # Assign labels (PRS = 1, RRS = 0)
+    prs_labels = [1] * len(prs_probs)
+    rrs_labels = [0] * len(rrs_probs)
+
+    probs = np.array(prs_probs + rrs_probs)
+    labels = np.array(prs_labels + rrs_labels)
+
+    # Compute ROC curve and AUC
+    fpr, tpr, thresholds = roc_curve(labels, probs)
+    roc_auc = auc(fpr, tpr)
+
+    # Filter valid thresholds
+    finite_idxs = np.where(np.isfinite(thresholds))[0]
+    fpr = fpr[finite_idxs]
+    tpr = tpr[finite_idxs]
+    thresholds = thresholds[finite_idxs]
+
+    valid_thresholds_idxs = np.where((thresholds >= 0) & (thresholds <= 1))[0]
+    fpr = fpr[valid_thresholds_idxs]
+    tpr = tpr[valid_thresholds_idxs]
+    thresholds = thresholds[valid_thresholds_idxs]
+
+    # Compute best F1 score
+    best_f1 = -1.0
+    best_thresh = None
+    for thresh in thresholds:
+        predicted_labels = (probs >= thresh).astype(int)
+        current_f1 = f1_score(labels, predicted_labels)
+        if current_f1 > best_f1:
+            best_f1 = current_f1
+            best_thresh = thresh
+
+    # Generate ROC plot using figure and axes approach (like original roc.py)
+    fig, ax = plt.subplots(figsize=(10, 8))
+    plt.rcParams['font.family'] = 'DejaVu Sans'  # More portable than Arial
+
+    # Color-coded by threshold
+    norm = plt.Normalize(vmin=thresholds.min(), vmax=thresholds.max())
+    cmap = plt.cm.viridis
+
+    for i in range(len(fpr) - 1):
+        x = fpr[i:i + 2]
+        y = tpr[i:i + 2]
+        z = thresholds[i]
+        ax.plot(x, y, color=cmap(norm(z)), lw=2.5)
+
+    ax.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+    cbar = fig.colorbar(sm, ax=ax)
+    cbar.set_label('Threshold', fontsize=14)
+
+    ax.set_xlim([0.0, 1.0])
+    ax.set_ylim([0.0, 1.05])
+    ax.set_xlabel('False Positive Rate', fontsize=14)
+    ax.set_ylabel('True Positive Rate', fontsize=14)
+    ax.set_title('ROC Curve', fontsize=16)
+
+    legend_text = f'AUC = {roc_auc:.3f}, Best F1 = {best_f1:.3f}, Threshold = {best_thresh:.3f}'
+    ax.legend([legend_text], loc="lower right", fontsize=11)
+    ax.grid(True, linestyle='--', linewidth=0.5, alpha=0.7)
+
+    plt.tight_layout()
+    plt.savefig(output_plot_path, dpi=150, format='png')
+    plt.close(fig)
+
+    return roc_auc, best_f1, best_thresh
+
+def compute_les(iterations, values):
+    """Compute Learning Efficiency Score (area under curve)."""
+    if len(iterations) < 2 or len(values) < 2:
+        return 0.0
+
+    # Use numpy trapezoid integration
+    # Normalize iterations to [0, 1] for comparable LES across different training lengths
+    iters = np.array(iterations, dtype=float)
+    vals = np.array(values, dtype=float)
+
+    # Remove any inf iterations (final checkpoint)
+    valid_mask = np.isfinite(iters)
+    iters = iters[valid_mask]
+    vals = vals[valid_mask]
+
+    if len(iters) < 2:
+        return 0.0
+
+    # Normalize iterations
+    iters_normalized = (iters - iters.min()) / (iters.max() - iters.min())
+
+    # Compute area under curve using trapezoidal rule
+    les = np.trapezoid(vals, iters_normalized)
+
+    return les
+
+def plot_metric_trajectory(iterations, values, metric_name, output_path, les_value):
+    """Plot a single metric trajectory across checkpoints."""
+    plt.figure(figsize=(10, 6))
+
+    # Filter out inf iterations
+    valid_mask = [i < float('inf') for i in iterations]
+    plot_iters = [it for it, v in zip(iterations, valid_mask) if v]
+    plot_vals = [val for val, v in zip(values, valid_mask) if v]
+
+    plt.plot(plot_iters, plot_vals, 'bo-', linewidth=2, markersize=8)
+    plt.fill_between(plot_iters, plot_vals, alpha=0.3)
+
+    plt.xlabel('Training Iteration', fontsize=14)
+    plt.ylabel(metric_name, fontsize=14)
+    plt.title(f'{metric_name} vs Training Iteration\nLES-{metric_name} = {les_value:.4f}', fontsize=14)
+    plt.grid(True, linestyle='--', alpha=0.7)
+
+    # Add value annotations
+    for i, (it, val) in enumerate(zip(plot_iters, plot_vals)):
+        if i % max(1, len(plot_iters) // 10) == 0:  # Annotate every ~10% of points
+            plt.annotate(f'{val:.3f}', (it, val), textcoords="offset points",
+                        xytext=(0, 10), ha='center', fontsize=9)
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150)
+    plt.close()
+
+def plot_combined_trajectories(iterations, auc_vals, f1_vals, thresh_vals, output_path, les_values):
+    """Plot all metrics on a single figure."""
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+    # Filter out inf iterations
+    valid_mask = [i < float('inf') for i in iterations]
+    plot_iters = [it for it, v in zip(iterations, valid_mask) if v]
+    plot_auc = [val for val, v in zip(auc_vals, valid_mask) if v]
+    plot_f1 = [val for val, v in zip(f1_vals, valid_mask) if v]
+    plot_thresh = [val for val, v in zip(thresh_vals, valid_mask) if v]
+
+    # AUC plot
+    axes[0].plot(plot_iters, plot_auc, 'bo-', linewidth=2, markersize=6)
+    axes[0].fill_between(plot_iters, plot_auc, alpha=0.3)
+    axes[0].set_xlabel('Training Iteration')
+    axes[0].set_ylabel('AUC')
+    axes[0].set_title(f'AUC Trajectory\nLES-AUC = {les_values["AUC"]:.4f}')
+    axes[0].grid(True, linestyle='--', alpha=0.7)
+    axes[0].set_ylim([0, 1.05])
+
+    # F1 plot
+    axes[1].plot(plot_iters, plot_f1, 'go-', linewidth=2, markersize=6)
+    axes[1].fill_between(plot_iters, plot_f1, alpha=0.3, color='green')
+    axes[1].set_xlabel('Training Iteration')
+    axes[1].set_ylabel('Best F1')
+    axes[1].set_title(f'Best F1 Trajectory\nLES-F1 = {les_values["F1"]:.4f}')
+    axes[1].grid(True, linestyle='--', alpha=0.7)
+    axes[1].set_ylim([0, 1.05])
+
+    # Threshold plot
+    axes[2].plot(plot_iters, plot_thresh, 'ro-', linewidth=2, markersize=6)
+    axes[2].fill_between(plot_iters, plot_thresh, alpha=0.3, color='red')
+    axes[2].set_xlabel('Training Iteration')
+    axes[2].set_ylabel('Best F1 Threshold')
+    axes[2].set_title(f'Threshold Trajectory\nLES-Threshold = {les_values["Threshold"]:.4f}')
+    axes[2].grid(True, linestyle='--', alpha=0.7)
+    axes[2].set_ylim([0, 1.05])
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150)
+    plt.close()
+
+# -----------------------------------------------------------------------------
+# Main execution
+# -----------------------------------------------------------------------------
+def main():
+    args, extra_args = parse_args()
+
+    # Validate inputs
+    if not os.path.exists(args.checkpoint_dir):
+        print(f"ERROR: Checkpoint directory not found: {args.checkpoint_dir}")
+        sys.exit(1)
+
+    if not os.path.exists(args.prs_file):
+        print(f"ERROR: PRS file not found: {args.prs_file}")
+        sys.exit(1)
+
+    if not os.path.exists(args.rrs_file):
+        print(f"ERROR: RRS file not found: {args.rrs_file}")
+        sys.exit(1)
+
+    # Create output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+
+    # Find sample script
+    # Note: Both vanilla and HOPE models trained with train_hope_v3.py use the same
+    # checkpoint format, so we always use the HOPE sample script. For vanilla models,
+    # we just skip the HOPE-specific arguments (Titan, surprise updates, etc.)
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    sample_script = os.path.join(script_dir, 'sample_fasta3.3_softmax_error_handling3e_hope_v3.py')
+    model_type = "Vanilla GPT (trained with train_hope_v3.py)" if args.vanilla else "HOPE"
+
+    if not os.path.exists(sample_script):
+        print(f"ERROR: Sample script not found: {sample_script}")
+        sys.exit(1)
+
+    # Get checkpoints
+    checkpoints = get_checkpoints(args.checkpoint_dir, args.checkpoint_pattern, args.include_final)
+
+    if not checkpoints:
+        print(f"ERROR: No checkpoints found matching pattern '{args.checkpoint_pattern}' in {args.checkpoint_dir}")
+        sys.exit(1)
+
+    print(f"\n{'='*60}")
+    print("LES-wrapper: Learning Efficiency Score Evaluation")
+    print(f"{'='*60}")
+    print(f"Model type: {model_type}")
+    print(f"Checkpoint directory: {args.checkpoint_dir}")
+    print(f"PRS file: {args.prs_file}")
+    print(f"RRS file: {args.rrs_file}")
+    print(f"Output directory: {args.output_dir}")
+    print(f"Found {len(checkpoints)} checkpoints")
+    print(f"{'='*60}\n")
+
+    # Build extra args for sample script (only for HOPE models)
+    sample_extra_args = []
+    if not args.vanilla:
+        # HOPE-specific arguments
+        if args.use_titan_in_forward >= 0:
+            sample_extra_args.extend(['--use_titan_in_forward', str(args.use_titan_in_forward)])
+        if args.enable_surprise_updates:
+            sample_extra_args.extend(['--enable_surprise_updates', str(args.enable_surprise_updates)])
+        if args.surprise_update_in_eval:
+            sample_extra_args.extend(['--surprise_update_in_eval', str(args.surprise_update_in_eval)])
+        if args.adapt_mode != 'none':
+            sample_extra_args.extend(['--adapt_mode', args.adapt_mode])
+        if args.adapt_steps > 0:
+            sample_extra_args.extend(['--adapt_steps', str(args.adapt_steps)])
+        if args.memory_state_in:
+            sample_extra_args.extend(['--memory_state_in', args.memory_state_in])
+
+        # Teaching file arguments
+        if args.teach_file:
+            sample_extra_args.extend(['--teach_file', args.teach_file])
+            sample_extra_args.extend(['--teach_delim', args.teach_delim])
+            sample_extra_args.extend(['--teach_has_header', str(args.teach_has_header)])
+            sample_extra_args.extend(['--teach_reset_policy', args.teach_reset_policy])
+            sample_extra_args.extend(['--teach_shuffle', str(args.teach_shuffle)])
+            if args.teach_max_rows > 0:
+                sample_extra_args.extend(['--teach_max_rows', str(args.teach_max_rows)])
+
+    # Add any extra arguments passed through
+    sample_extra_args.extend(extra_args)
+
+    # Results storage
+    results = []
+    iterations = []
+    auc_values = []
+    f1_values = []
+    thresh_values = []
+
+    # Process each checkpoint
+    for idx, (ckpt_name, iteration, ckpt_path) in enumerate(checkpoints):
+        iter_str = str(iteration) if iteration < float('inf') else 'final'
+        print(f"\n[{idx+1}/{len(checkpoints)}] Processing checkpoint: {ckpt_name} (iteration {iter_str})")
+
+        # Create subdirectory for this checkpoint
+        ckpt_subdir = os.path.join(args.output_dir, f"ckpt_{iter_str}")
+        os.makedirs(ckpt_subdir, exist_ok=True)
+
+        prs_prefix = f"PRS_iter{iter_str}"
+        rrs_prefix = f"RRS_iter{iter_str}"
+
+        prs_csv = os.path.join(ckpt_subdir, f"{prs_prefix}_probabilities.csv")
+        rrs_csv = os.path.join(ckpt_subdir, f"{rrs_prefix}_probabilities.csv")
+
+        if not args.skip_inference:
+            # Run inference for PRS
+            print(f"  Running PRS inference...")
+            if not run_inference(sample_script, args.checkpoint_dir, ckpt_name,
+                               args.prs_file, ckpt_subdir, prs_prefix, sample_extra_args,
+                               vanilla=args.vanilla):
+                print(f"  SKIPPING checkpoint due to inference error")
+                continue
+
+            # Run inference for RRS
+            print(f"  Running RRS inference...")
+            if not run_inference(sample_script, args.checkpoint_dir, ckpt_name,
+                               args.rrs_file, ckpt_subdir, rrs_prefix, sample_extra_args,
+                               vanilla=args.vanilla):
+                print(f"  SKIPPING checkpoint due to inference error")
+                continue
+
+        # Extract probabilities
+        print(f"  Extracting probabilities...")
+        prs_probs = extract_probabilities_from_csv(prs_csv)
+        rrs_probs = extract_probabilities_from_csv(rrs_csv)
+
+        if not prs_probs or not rrs_probs:
+            print(f"  WARNING: Could not extract probabilities, skipping")
+            continue
+
+        print(f"  PRS samples: {len(prs_probs)}, RRS samples: {len(rrs_probs)}")
+
+        # Combine probabilities
+        combined_csv = os.path.join(ckpt_subdir, f"combined_probabilities_iter{iter_str}.csv")
+        combine_probabilities(prs_probs, rrs_probs, combined_csv)
+
+        # Run ROC analysis
+        print(f"  Running ROC analysis...")
+        roc_plot = os.path.join(ckpt_subdir, f"ROC_iter{iter_str}.png")
+        roc_auc, best_f1, best_thresh = run_roc_analysis_internal(combined_csv, roc_plot)
+
+        if roc_auc is None:
+            print(f"  WARNING: ROC analysis failed, skipping")
+            continue
+
+        print(f"  Results: AUC={roc_auc:.4f}, F1={best_f1:.4f}, Threshold={best_thresh:.4f}")
+
+        # Store results
+        results.append({
+            'checkpoint': ckpt_name,
+            'iteration': iteration if iteration < float('inf') else 'final',
+            'AUC': roc_auc,
+            'Best_F1': best_f1,
+            'Best_F1_Threshold': best_thresh,
+            'PRS_samples': len(prs_probs),
+            'RRS_samples': len(rrs_probs)
+        })
+
+        iterations.append(iteration)
+        auc_values.append(roc_auc)
+        f1_values.append(best_f1)
+        thresh_values.append(best_thresh)
+
+    # Compute LES values
+    print(f"\n{'='*60}")
+    print("Computing Learning Efficiency Scores (LES)")
+    print(f"{'='*60}")
+
+    les_auc = compute_les(iterations, auc_values)
+    les_f1 = compute_les(iterations, f1_values)
+    les_thresh = compute_les(iterations, thresh_values)
+
+    les_values = {
+        'AUC': les_auc,
+        'F1': les_f1,
+        'Threshold': les_thresh
+    }
+
+    print(f"  LES-AUC: {les_auc:.6f}")
+    print(f"  LES-F1: {les_f1:.6f}")
+    print(f"  LES-Threshold: {les_thresh:.6f}")
+
+    # Generate trajectory plots
+    if not args.no_plots and len(iterations) >= 2:
+        print(f"\nGenerating trajectory plots...")
+
+        # Individual plots
+        plot_metric_trajectory(iterations, auc_values, 'AUC',
+                              os.path.join(args.output_dir, 'trajectory_AUC.png'), les_auc)
+        plot_metric_trajectory(iterations, f1_values, 'Best F1',
+                              os.path.join(args.output_dir, 'trajectory_F1.png'), les_f1)
+        plot_metric_trajectory(iterations, thresh_values, 'Best F1 Threshold',
+                              os.path.join(args.output_dir, 'trajectory_Threshold.png'), les_thresh)
+
+        # Combined plot
+        plot_combined_trajectories(iterations, auc_values, f1_values, thresh_values,
+                                  os.path.join(args.output_dir, 'trajectory_combined.png'), les_values)
+
+        print(f"  Saved trajectory plots to {args.output_dir}")
+
+    # Generate summary table
+    print(f"\nGenerating summary table...")
+    summary_csv = os.path.join(args.output_dir, 'summary_table.csv')
+    with open(summary_csv, 'w', newline='') as f:
+        writer = csv.DictWriter(f, fieldnames=['checkpoint', 'iteration', 'AUC', 'Best_F1',
+                                               'Best_F1_Threshold', 'PRS_samples', 'RRS_samples'])
+        writer.writeheader()
+        writer.writerows(results)
+
+    # Add LES row
+    with open(summary_csv, 'a', newline='') as f:
+        f.write(f"\nLES (Learning Efficiency Score),---,{les_auc:.6f},{les_f1:.6f},{les_thresh:.6f},---,---\n")
+
+    print(f"  Saved summary table to {summary_csv}")
+
+    # Generate JSON manifest
+    manifest = {
+        'timestamp': datetime.now().isoformat(),
+        'checkpoint_dir': args.checkpoint_dir,
+        'prs_file': args.prs_file,
+        'rrs_file': args.rrs_file,
+        'output_dir': args.output_dir,
+        'num_checkpoints': len(checkpoints),
+        'num_successful': len(results),
+        'LES': {
+            'AUC': les_auc,
+            'F1': les_f1,
+            'Threshold': les_thresh
+        },
+        'results': results
+    }
+
+    manifest_path = os.path.join(args.output_dir, 'manifest.json')
+    with open(manifest_path, 'w') as f:
+        json.dump(manifest, f, indent=2, default=str)
+
+    print(f"  Saved manifest to {manifest_path}")
+
+    # Print final summary
+    print(f"\n{'='*60}")
+    print("FINAL SUMMARY")
+    print(f"{'='*60}")
+    print(f"Checkpoints processed: {len(results)}/{len(checkpoints)}")
+    print(f"\nLearning Efficiency Scores (LES):")
+    print(f"  LES-AUC:       {les_auc:.6f}")
+    print(f"  LES-F1:        {les_f1:.6f}")
+    print(f"  LES-Threshold: {les_thresh:.6f}")
+
+    if results:
+        final_result = results[-1]
+        print(f"\nFinal Checkpoint Performance:")
+        print(f"  AUC:       {final_result['AUC']:.4f}")
+        print(f"  Best F1:   {final_result['Best_F1']:.4f}")
+        print(f"  Threshold: {final_result['Best_F1_Threshold']:.4f}")
+
+    print(f"\nOutputs saved to: {args.output_dir}")
+    print(f"{'='*60}\n")
+
+if __name__ == '__main__':
+    main()

LICENSE

@@ -0,0 +1,39 @@
+MIT License
+
+Copyright (c) 2022 Andrej Karpathy (nanoGPT -- original framework)
+Copyright (c) 2026 Kourosh Salehi-Ashtiani (ppiGPLM -- modifications and additions)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This repository is a derivative of nanoGPT (https://github.com/karpathy/nanoGPT)
+by Andrej Karpathy, originally released under the MIT License.
+
+Modifications and additions by Kourosh Salehi-Ashtiani include:
+  - Repurposing GPT-2 for binary protein-protein interaction classification
+    via next-token prediction on structured protein pair prompts
+  - sample_fasta3.3_softmax_error_handling3e.py: Batch inference script
+    with softmax probability extraction for PPI classification
+  - LES-wrapper.py: Learning Efficiency Score evaluation wrapper for
+    automated multi-checkpoint ROC analysis
+  - roc_analysis_color_threshold_F1e.py: ROC curve analysis with
+    threshold-colored visualization and F1 optimization
+  - Training configuration for character-level protein pair language models
+  - Data preparation pipeline for MED4 PPI datasets

MED4_100_PRS.csv

@@ -0,0 +1,101 @@
+<ps1>,MNTRKKNPKRGVGKTETNTEWLDKVINQLINKDFSQYL,<ps2>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<
+<ps1>,LVESTQSQDSNLGTRLQQDLKNDLIAGLLVVIPLATTIWLSSIVSKFVLTLVTSVPKQLNPFITLNPLLQDLINLTLGLTVPLLAILLIGLMARNFVGRWLLEFGEGTLSKIPVAGAVYKTLKQLLETFLSNKSNRFRRVVLVEYPREGLFSVGFVTGDVGPSLQSELDEKLLSVFIPTAPNPTTGWYTLVPESSVKDLAISVEDAFRTIISVGIVNPDEKDSSSNPTFSKLFSQLRASTNTSST,<ps2>,LVESTQSQDSNLGTRLQQDLKNDLIAGLLVVIPLATTIWLSSIVSKFVLTLVTSVPKQLNPFITLNPLLQDLINLTLGLTVPLLAILLIGLMARNFVGRWLLEFGEGTLSKIPVAGAVYKTLKQLLETFLSNKSNRFRRVVLVEYPREGLFSVGFVTGDVGPSLQSELDEKLLSVFIPTAPNPTTGWYTLVPESSVKDLAISVEDAFRTIISVGIVNPDEKDSSSNPTFSKLFSQLRASTNTSST,<
+<ps1>,LMHNRSLSRELSLLSLGLIKDTADLELNKIQIDEIFESALDSLINHCRDELDNCEADLENVSQHILDSELKEGSNSSFANVRDELKKAFYKMESVMNSLSVTLDFPKLIVSSNQIDIREDVNHRILSIINNLKSIDSEIDEVMDRWRLKRLPRVDRDILRLAYVDIHFLDTPVAVACDEAVNLANKYCDTQGRKMINGVLRRLQRVKVN,<ps2>,LMHNRSLSRELSLLSLGLIKDTADLELNKIQIDEIFESALDSLINHCRDELDNCEADLENVSQHILDSELKEGSNSSFANVRDELKKAFYKMESVMNSLSVTLDFPKLIVSSNQIDIREDVNHRILSIINNLKSIDSEIDEVMDRWRLKRLPRVDRDILRLAYVDIHFLDTPVAVACDEAVNLANKYCDTQGRKMINGVLRRLQRVKVN,<
+<ps1>,MNQFFSRRSFILIPIMSILKFILQPKKVLAAFAASDDDWNLSKEDWKNKLSPESYYILREEGTERAFSSQLNNEKRKGIFYCAGCNQPLFTSDTKFDSGTGWPSFWDPIQGSVETKVDFKLIVPRTEYHCSRCGGHQGHVFNDGPLPTGKRYCNNGLALKFIAE,<ps2>,MNQFFSRRSFILIPIMSILKFILQPKKVLAAFAASDDDWNLSKEDWKNKLSPESYYILREEGTERAFSSQLNNEKRKGIFYCAGCNQPLFTSDTKFDSGTGWPSFWDPIQGSVETKVDFKLIVPRTEYHCSRCGGHQGHVFNDGPLPTGKRYCNNGLALKFIAE,<
+<ps1>,LVKPKSPDNKISNHLQQDVVKIAGKTIFINPFLYWRRFDENTNRWLREPGQMSEEQIQPNRNRFYPEIDWADLSQNQKLVKDASVEMFLKTLELISTFHPQLNSGQLLEVERKMAITKKLPFEKWVTKSFAKKARAEEYEKRKFKRDRFIRSWKEWLSLENTQQALLPIIVVVFVSAFIGWSSGVSKNSCNPYFEQNLDQSI,<ps2>,MKGHKKIRFIFPLVAMYVPLLLLAPKAIAGSFGAEIFCTMRDGGNDHESSWQAAYSYIKKQKGGIFKTSPKQAAGQIIETVVRERDKFSYCVEFLDQLHPDRKLQLENDRKEKRRKKEELLQDKENEDYSKETFDRYSY,<
+<ps1>,MDKPKNKNFANTASRISAIASSVMDLHVRIALQEVDREKRRLISGGVFIAMGGILLLLVLISIHVIFYLTLSKLNNWATEYNLLLIIFVDLFLAGLSLKLGGKLAKGPYLPQTLEGLGKTTKAVLGKK,<ps2>,MDKPKNKNFANTASRISAIASSVMDLHVRIALQEVDREKRRLISGGVFIAMGGILLLLVLISIHVIFYLTLSKLNNWATEYNLLLIIFVDLFLAGLSLKLGGKLAKGPYLPQTLEGLGKTTKAVLGKK,<
+<ps1>,MQSKTKELDPILEVNNLFASIENLPILKGVTISVNPGEIHAIMGRNGCGKSTLSKIIAGHPSYKITKGEIKFTGNDIQSLEPEERAQSGIFLGFQYPIEIPGVSNLEFLRVATNARRKFLNKEELDTFDFEDLVKEKLDLVKMDSAFLSRSINQGFSGGEKKRNEILQMALLEPKIAILDETDSGLDIDALRIVASGIKKISNEETGIILITHYQRLLDEIQPDYVHVMSDGQIIKTGESDLALELEKHGYEWTDNFIKEQ,<ps2>,MQSKTKELDPILEVNNLFASIENLPILKGVTISVNPGEIHAIMGRNGCGKSTLSKIIAGHPSYKITKGEIKFTGNDIQSLEPEERAQSGIFLGFQYPIEIPGVSNLEFLRVATNARRKFLNKEELDTFDFEDLVKEKLDLVKMDSAFLSRSINQGFSGGEKKRNEILQMALLEPKIAILDETDSGLDIDALRIVASGIKKISNEETGIILITHYQRLLDEIQPDYVHVMSDGQIIKTGESDLALELEKHGYEWTDNFIKEQ,<
+<ps1>,MSKVEIYTWRFCPFCIRAKSLLEKKNITFTEHKIDGDDNARELMMERANGKRTVPQIFIDDKSIGGCDELYELEKEDKLDLLLN,<ps2>,MSKVEIYTWRFCPFCIRAKSLLEKKNITFTEHKIDGDDNARELMMERANGKRTVPQIFIDDKSIGGCDELYELEKEDKLDLLLN,<
+<ps1>,VQFIDQANIILKAGKGGNGIVSFRREKFVPAGGPSGGNGGKGGSIIIIADNNLQTLLDFKFNREIFAKDGFKGGPNKRSGASGENTILKVPCGTEIRDFNTGIILGDLTEDKQSLTIAHGGRGGHGNAYYLSNQNRAPESFTEGKEGEIWEVQLELKLLAEVGIIGLPNAGKSTLISVLSSARPKIANYPFTTLIPNLGVVRKADGNGCLFADIPGLISGAAEGVGLGHDFLRHIQRTKILIHLIDSIAENPIRDFEIIEKELKRYGSGLLNKERIVVLNKMELVDENYLQTITKKLENLSKKKVLVISSSLRKGLSPLLSEVWKRI,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,MTTIQQQRTSLLKGWPQFCEWVTSTNNRIYVGWFGVLMIPCLLAAAACFIVAFIAAPPVDIDGIREPVAGSFLYGNNIISGAVVPSSNAIGLHFYPIWEAATVDEWLYNGGPYQLVIFHFLIGISAYMGRQWELSYRLGMRPWICVAYSAPVSAAFAVFLVYPFGQGSFSDGMPLGISGTFNFMFVFQAEHNILMHPFHMAGVAGMFGGSLFSAMHGSLVTSSLIRETTETESQNYGYKFGQEEETYNIVAAHGYFGRLIFQYASFNNSRSLHFFLAVFPVVCVWLTSMGICTMAFNLNGFNFNQSVVDANGKIVPTWGDVLNRANLGMEVMHERNAHNFPLDLAAAESTTVALTAPAIG,<ps2>,MTTIQQQRTSLLKGWPQFCEWVTSTNNRIYVGWFGVLMIPCLLAAAACFIVAFIAAPPVDIDGIREPVAGSFLYGNNIISGAVVPSSNAIGLHFYPIWEAATVDEWLYNGGPYQLVIFHFLIGISAYMGRQWELSYRLGMRPWICVAYSAPVSAAFAVFLVYPFGQGSFSDGMPLGISGTFNFMFVFQAEHNILMHPFHMAGVAGMFGGSLFSAMHGSLVTSSLIRETTETESQNYGYKFGQEEETYNIVAAHGYFGRLIFQYASFNNSRSLHFFLAVFPVVCVWLTSMGICTMAFNLNGFNFNQSVVDANGKIVPTWGDVLNRANLGMEVMHERNAHNFPLDLAAAESTTVALTAPAIG,<
+<ps1>,MSKVELISLTPEAEKTMAYIARVSNPSNQANDKFAGLLRYCIKHEHWSVFEQSCMTLKIETNRGIAAQILRHRSFTFQEFSQRYAETSLLGNEIPIPNLRRQDQKNRQNSIDDIPDELKIKFSEKISKHFQEANKLYEEMLNEGIAKECARFIMPLATPTRIYMTGSCRSWIHYIQLRSKEGTQKEHMEIAEDCKKVFIKYFPSVSEALNWE,<ps2>,MSKVELISLTPEAEKTMAYIARVSNPSNQANDKFAGLLRYCIKHEHWSVFEQSCMTLKIETNRGIAAQILRHRSFTFQEFSQRYAETSLLGNEIPIPNLRRQDQKNRQNSIDDIPDELKIKFSEKISKHFQEANKLYEEMLNEGIAKECARFIMPLATPTRIYMTGSCRSWIHYIQLRSKEGTQKEHMEIAEDCKKVFIKYFPSVSEALNWE,<
+<ps1>,VSGWLFIIFLLLLGGLISTLGDLLGSKIGKARFSILKLRPKKTAILITILTGSLISASSLFLMILVNRQLRVGLFRLGDLQKKLQESKQVLIPLEKEREKLENKIKAKETEFKQLERNIIALRSGKFVIRSGQSLIISEISSSNLKDIKSKIEKIIINANRYTHKIVKPKNKEVKNLLLLRKNHIEEMQNIILKGGNWVINIKSVRNVLTGENFVYAFPEITENKIIVRKGEKITKIDFKQEDFNKKDFGDKVNFLLSSSLAEIKRRGSLVNEIKLRGDSIKELRDFLNKNDKTNFELEAVSLFNSKTAQPVIVELNVNYPES,<ps2>,VSGWLFIIFLLLLGGLISTLGDLLGSKIGKARFSILKLRPKKTAILITILTGSLISASSLFLMILVNRQLRVGLFRLGDLQKKLQESKQVLIPLEKEREKLENKIKAKETEFKQLERNIIALRSGKFVIRSGQSLIISEISSSNLKDIKSKIEKIIINANRYTHKIVKPKNKEVKNLLLLRKNHIEEMQNIILKGGNWVINIKSVRNVLTGENFVYAFPEITENKIIVRKGEKITKIDFKQEDFNKKDFGDKVNFLLSSSLAEIKRRGSLVNEIKLRGDSIKELRDFLNKNDKTNFELEAVSLFNSKTAQPVIVELNVNYPES,<
+<ps1>,MNDRIIEFEPLIEGILIKRYKRFLADIQIENGEIVTAHCANTGPMKGLLNEGANVRISFSSSTKRKLPWTWEQVKVIGRDNKEVWVGINTLFANKLIRKVIEQNLFKDKLGEIAKIKSEVPYGKDKKSRIDFLLTPKSSNPDNRNIYVEVKNTTWTKNNVALFPDTETKRGQKHLIELKGLIPESKSVLVPCITRKDIDYFAPGDESDPLYGELFRESISAGMLLIPCCFEFHSDHVAWKGFKPLKLN,<ps2>,MNDRIIEFEPLIEGILIKRYKRFLADIQIENGEIVTAHCANTGPMKGLLNEGANVRISFSSSTKRKLPWTWEQVKVIGRDNKEVWVGINTLFANKLIRKVIEQNLFKDKLGEIAKIKSEVPYGKDKKSRIDFLLTPKSSNPDNRNIYVEVKNTTWTKNNVALFPDTETKRGQKHLIELKGLIPESKSVLVPCITRKDIDYFAPGDESDPLYGELFRESISAGMLLIPCCFEFHSDHVAWKGFKPLKLN,<
+<ps1>,MRRSLRDSIVGFSLLGGLLVFTFFSFWLRGVKLSSKNWYLFAEFNNASGLSKKSPVTYRGILVGSIEDILFTNESIKAKIVLNNPEIILPKPAFARVVTNSFLGGDVQVALETSEKTIPKNTPKAISDKCDSKLIICQGDTITGKQLSSLSNITNRINQLLKESNQENLIENVVNSIDQFDKTQENLDELIYLSKQEIIRVKPLIKEVTIAAGHLNNILSTINDEETLKDIKLTIEAAESISGKFDNMSDDFEQLMKDKELTKSIRDLTIGLSKFLNEIYP,<ps2>,MRRSLRDSIVGFSLLGGLLVFTFFSFWLRGVKLSSKNWYLFAEFNNASGLSKKSPVTYRGILVGSIEDILFTNESIKAKIVLNNPEIILPKPAFARVVTNSFLGGDVQVALETSEKTIPKNTPKAISDKCDSKLIICQGDTITGKQLSSLSNITNRINQLLKESNQENLIENVVNSIDQFDKTQENLDELIYLSKQEIIRVKPLIKEVTIAAGHLNNILSTINDEETLKDIKLTIEAAESISGKFDNMSDDFEQLMKDKELTKSIRDLTIGLSKFLNEIYP,<
+<ps1>,MASSETYEFLFVKPGDHVVIKNEKPPGNTQNGRQEYWIGQIISCIGGARNPNSWTLFQVADIDNGEIIIINADTVERILKTAEN,<ps2>,MASSETYEFLFVKPGDHVVIKNEKPPGNTQNGRQEYWIGQIISCIGGARNPNSWTLFQVADIDNGEIIIINADTVERILKTAEN,<
+<ps1>,LSVDRELLKEVTQELWNTVKKLRPEIDRETRLQLVLKALLTIGDLPDQLQAAMVVGVCAEMDKSDFENADGNSNTKEESNSTSVDTSTGRKVFRRSSAK,<ps2>,LSVDRELLKEVTQELWNTVKKLRPEIDRETRLQLVLKALLTIGDLPDQLQAAMVVGVCAEMDKSDFENADGNSNTKEESNSTSVDTSTGRKVFRRSSAK,<
+<ps1>,LQIGDKVPQFSLLDQNGTKRSNNGLKTPLVLFFYPKDDTPGCTIEVCGFRDKYDLFKVLGAQVWGVSNGSSSSHLAFANKNKLQYPLLCDKNDSLRKAFKVPKVLGLLDGRVTYVIDRNGFVKHIFRDLLNGPEHIKEAIRVLKEIQNQ,<ps2>,LQIGDKVPQFSLLDQNGTKRSNNGLKTPLVLFFYPKDDTPGCTIEVCGFRDKYDLFKVLGAQVWGVSNGSSSSHLAFANKNKLQYPLLCDKNDSLRKAFKVPKVLGLLDGRVTYVIDRNGFVKHIFRDLLNGPEHIKEAIRVLKEIQNQ,<
+<ps1>,MFSINKSNFMKKIGMQAVDEAIENGIDLDGTPIPSKMLELYNRIMSEENKRERSGVKKSMRNRCVKTGSKHFDKETLDQLLIDSGWEGLKEKEILFFYS,<ps2>,MFSINKSNFMKKIGMQAVDEAIENGIDLDGTPIPSKMLELYNRIMSEENKRERSGVKKSMRNRCVKTGSKHFDKETLDQLLIDSGWEGLKEKEILFFYS,<
+<ps1>,VNSNSSNQVGKNIRRTGFLIVLSYLLIVLIMKVLEANNFFGYSLSSFSNDIFAPPSLKHLCGTDRLGRDVCLRTLQGSSIAIEVVFLAIFFALILGLPLGLLSGYFGGILDKCLSLVMDTIFSIPVILLAVVVAFVLGKGIINASIALCIVYSPQYFRLIRNQTMLIKSETYVEAARVSGADVKTIIFKYILPNVITPLPILLTLNAADAVLVLGSLGFLGLGVPANVPEWGSDLNLALAAIPTGIWWTALFPGLAMFFLVLGLSFIGEELENIFEN,<ps2>,LEGINLNQIGVSFKGSGSYVPNQILTNQEISKKVETSDEWIKSRTGISQRRISGLSENVSEMGYKAALGAIEMARWDIETIDLIILATSTPNDLFGSAPEIQSKLGAINAVAFDLTAACSGFLFAAITATQFLKAGSYKRAVVIGSDQLSSYVDWNDRRSCILFGDGAGAIAIEGTNELDNLLGFSMRTDGQRGSFLNLPSQNNQDLIINDINFSSGGFSSIKMNGQEVYKFAVREVPLIIDNLFKKTNFNSEKINWLLLHQANQRILDSVGERLNVSTEKILSNLSNYGNTSAATIPLMLDEAIRNKKIKENDIIATSGFGAGLSWGAALIRWG,<
+<ps1>,MSNTESLTGKVALITGASRGIGKEIALELSNLGAKVIINYSSSDEKAEEVVNLIKESGGKVHKLKFDVSKEESVSKAFEEIIKINGAIDILVNNAGITRDGLLMRMKSEQWDDVLNTNLKGVFLCTKYASKFMIKKRSGKIINISSIVGIIGNPGQANYSAAKAGVIGFTKTCAKEFASRGINVNAIAPGFIETEMTEKLNNEEIIKAIPLGKLGSCSQIANLVSFLVSSNAGSYITGQTISIDGGMSI,<ps2>,MSNTESLTGKVALITGASRGIGKEIALELSNLGAKVIINYSSSDEKAEEVVNLIKESGGKVHKLKFDVSKEESVSKAFEEIIKINGAIDILVNNAGITRDGLLMRMKSEQWDDVLNTNLKGVFLCTKYASKFMIKKRSGKIINISSIVGIIGNPGQANYSAAKAGVIGFTKTCAKEFASRGINVNAIAPGFIETEMTEKLNNEEIIKAIPLGKLGSCSQIANLVSFLVSSNAGSYITGQTISIDGGMSI,<
+<ps1>,MHKVLAIETSCDETSVSIVSNSGDIYKIHSNIVASQIEDHSKWGGVVPELAARKHLELLPFVLEQALEESKIRIEKIDVIASTVTPGLVGCLRVGSITARSLCTLYSKPFLGIHHLEGHLSSILFSKNYPKPPFLTLLVSGGHTELIKVGERRKMQRLGRSYDDAAGEAFDKVGRLLGLSYPGGPAIAKIAKKGNASKFNLPKCKISDKEGGFLKYDFSFSGLKTAVLRLVEKINLNGDEIPIPDIAASFERVVAEVLVERTIKCANDYGLDNIVVVGGVAANDTLRKMMISEACKKSIKVHLAPINLCTDNAAMIGAAALYRLKFKAYESSLKLGISGRLPIDQANTLYENKPPF,<ps2>,LVKPKSPDNKISNHLQQDVVKIAGKTIFINPFLYWRRFDENTNRWLREPGQMSEEQIQPNRNRFYPEIDWADLSQNQKLVKDASVEMFLKTLELISTFHPQLNSGQLLEVERKMAITKKLPFEKWVTKSFAKKARAEEYEKRKFKRDRFIRSWKEWLSLENTQQALLPIIVVVFVSAFIGWSSGVSKNSCNPYFEQNLDQSI,<
+<ps1>,MHKVLAIETSCDETSVSIVSNSGDIYKIHSNIVASQIEDHSKWGGVVPELAARKHLELLPFVLEQALEESKIRIEKIDVIASTVTPGLVGCLRVGSITARSLCTLYSKPFLGIHHLEGHLSSILFSKNYPKPPFLTLLVSGGHTELIKVGERRKMQRLGRSYDDAAGEAFDKVGRLLGLSYPGGPAIAKIAKKGNASKFNLPKCKISDKEGGFLKYDFSFSGLKTAVLRLVEKINLNGDEIPIPDIAASFERVVAEVLVERTIKCANDYGLDNIVVVGGVAANDTLRKMMISEACKKSIKVHLAPINLCTDNAAMIGAAALYRLKFKAYESSLKLGISGRLPIDQANTLYENKPPF,<ps2>,VNSNSSNQVGKNIRRTGFLIVLSYLLIVLIMKVLEANNFFGYSLSSFSNDIFAPPSLKHLCGTDRLGRDVCLRTLQGSSIAIEVVFLAIFFALILGLPLGLLSGYFGGILDKCLSLVMDTIFSIPVILLAVVVAFVLGKGIINASIALCIVYSPQYFRLIRNQTMLIKSETYVEAARVSGADVKTIIFKYILPNVITPLPILLTLNAADAVLVLGSLGFLGLGVPANVPEWGSDLNLALAAIPTGIWWTALFPGLAMFFLVLGLSFIGEELENIFEN,<
+<ps1>,MHKVLAIETSCDETSVSIVSNSGDIYKIHSNIVASQIEDHSKWGGVVPELAARKHLELLPFVLEQALEESKIRIEKIDVIASTVTPGLVGCLRVGSITARSLCTLYSKPFLGIHHLEGHLSSILFSKNYPKPPFLTLLVSGGHTELIKVGERRKMQRLGRSYDDAAGEAFDKVGRLLGLSYPGGPAIAKIAKKGNASKFNLPKCKISDKEGGFLKYDFSFSGLKTAVLRLVEKINLNGDEIPIPDIAASFERVVAEVLVERTIKCANDYGLDNIVVVGGVAANDTLRKMMISEACKKSIKVHLAPINLCTDNAAMIGAAALYRLKFKAYESSLKLGISGRLPIDQANTLYENKPPF,<ps2>,MHKVLAIETSCDETSVSIVSNSGDIYKIHSNIVASQIEDHSKWGGVVPELAARKHLELLPFVLEQALEESKIRIEKIDVIASTVTPGLVGCLRVGSITARSLCTLYSKPFLGIHHLEGHLSSILFSKNYPKPPFLTLLVSGGHTELIKVGERRKMQRLGRSYDDAAGEAFDKVGRLLGLSYPGGPAIAKIAKKGNASKFNLPKCKISDKEGGFLKYDFSFSGLKTAVLRLVEKINLNGDEIPIPDIAASFERVVAEVLVERTIKCANDYGLDNIVVVGGVAANDTLRKMMISEACKKSIKVHLAPINLCTDNAAMIGAAALYRLKFKAYESSLKLGISGRLPIDQANTLYENKPPF,<
+<ps1>,MIKNPIQEVTNKLQYRAIGIVKGIYKPNNIDQLNRGTLTDKEGKIIETVILGKAIALIKKYINLEKDYFWIVYPRNKNINNLHLQVAGIWDPYQLNQFDKNNSEKDPNQLLEELNLNNNYFSIRGELVYVNIKKKEIVIKICSSPPSKRSKYLTFKIIIEGEIPLQFLNNFVSLDVIRDGNTLRMAKYEIIEKIKPEKV,<ps2>,MIKNPIQEVTNKLQYRAIGIVKGIYKPNNIDQLNRGTLTDKEGKIIETVILGKAIALIKKYINLEKDYFWIVYPRNKNINNLHLQVAGIWDPYQLNQFDKNNSEKDPNQLLEELNLNNNYFSIRGELVYVNIKKKEIVIKICSSPPSKRSKYLTFKIIIEGEIPLQFLNNFVSLDVIRDGNTLRMAKYEIIEKIKPEKV,<
+<ps1>,MTKFKLKIASRRSKLAMVQTLWVKEQLEKNIPDLEVSIEAMATQGDKILDVALAKIGDKGLFTKELEAQMLVGHADIAVHSLKDLPTNLPDGLTLGCITKREDPSDALVVNKKNKIYQLESLPPGSIVGTSSLRRLAQLRYKFPHLDFKDIRGNVITRIEKLDSGEFDCIILAAAGLKRLGFESRVHQIIPNEISLHAVGQGALGIECKSDDKEVLKIISVLEDKVSSQRCLAERSFLRELEGGCQVPIGVNSSIQNDEIALIGMVASIDGKRLIKNESIGNIKYPEEVGKKLAEKLKLQGADKILSEIFEQFRDK,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,MTKFKLKIASRRSKLAMVQTLWVKEQLEKNIPDLEVSIEAMATQGDKILDVALAKIGDKGLFTKELEAQMLVGHADIAVHSLKDLPTNLPDGLTLGCITKREDPSDALVVNKKNKIYQLESLPPGSIVGTSSLRRLAQLRYKFPHLDFKDIRGNVITRIEKLDSGEFDCIILAAAGLKRLGFESRVHQIIPNEISLHAVGQGALGIECKSDDKEVLKIISVLEDKVSSQRCLAERSFLRELEGGCQVPIGVNSSIQNDEIALIGMVASIDGKRLIKNESIGNIKYPEEVGKKLAEKLKLQGADKILSEIFEQFRDK,<ps2>,VNSNSSNQVGKNIRRTGFLIVLSYLLIVLIMKVLEANNFFGYSLSSFSNDIFAPPSLKHLCGTDRLGRDVCLRTLQGSSIAIEVVFLAIFFALILGLPLGLLSGYFGGILDKCLSLVMDTIFSIPVILLAVVVAFVLGKGIINASIALCIVYSPQYFRLIRNQTMLIKSETYVEAARVSGADVKTIIFKYILPNVITPLPILLTLNAADAVLVLGSLGFLGLGVPANVPEWGSDLNLALAAIPTGIWWTALFPGLAMFFLVLGLSFIGEELENIFEN,<
+<ps1>,MTKFKLKIASRRSKLAMVQTLWVKEQLEKNIPDLEVSIEAMATQGDKILDVALAKIGDKGLFTKELEAQMLVGHADIAVHSLKDLPTNLPDGLTLGCITKREDPSDALVVNKKNKIYQLESLPPGSIVGTSSLRRLAQLRYKFPHLDFKDIRGNVITRIEKLDSGEFDCIILAAAGLKRLGFESRVHQIIPNEISLHAVGQGALGIECKSDDKEVLKIISVLEDKVSSQRCLAERSFLRELEGGCQVPIGVNSSIQNDEIALIGMVASIDGKRLIKNESIGNIKYPEEVGKKLAEKLKLQGADKILSEIFEQFRDK,<ps2>,MTKFKLKIASRRSKLAMVQTLWVKEQLEKNIPDLEVSIEAMATQGDKILDVALAKIGDKGLFTKELEAQMLVGHADIAVHSLKDLPTNLPDGLTLGCITKREDPSDALVVNKKNKIYQLESLPPGSIVGTSSLRRLAQLRYKFPHLDFKDIRGNVITRIEKLDSGEFDCIILAAAGLKRLGFESRVHQIIPNEISLHAVGQGALGIECKSDDKEVLKIISVLEDKVSSQRCLAERSFLRELEGGCQVPIGVNSSIQNDEIALIGMVASIDGKRLIKNESIGNIKYPEEVGKKLAEKLKLQGADKILSEIFEQFRDK,<
+<ps1>,MLVKKMTELFSRFFVKAISFAICISVFFTLFNSPSYAAKTSMTGDYAKDTISVVKTLQIAVETPKDSPDKDKVRDESLALITDYISRYRNRGMVNKTQSFTTMQTALNAMAGHYKNFATRPLPDKLKERLTKEFTLAEKMVLRES,<ps2>,MLVKKMTELFSRFFVKAISFAICISVFFTLFNSPSYAAKTSMTGDYAKDTISVVKTLQIAVETPKDSPDKDKVRDESLALITDYISRYRNRGMVNKTQSFTTMQTALNAMAGHYKNFATRPLPDKLKERLTKEFTLAEKMVLRES,<
+<ps1>,LKKITSILIIFFLIVLYPIRTYSAEILQINNSSSILVGDQNRDLPIKLFCVEINNEDDEKIALNLLKKEFPRGSKVKIKPIGFKENILTARVFNINETKEMSDLLISKNLSKETCQN,<ps2>,LKKITSILIIFFLIVLYPIRTYSAEILQINNSSSILVGDQNRDLPIKLFCVEINNEDDEKIALNLLKKEFPRGSKVKIKPIGFKENILTARVFNINETKEMSDLLISKNLSKETCQN,<
+<ps1>,MESIFNNSFATLVAYVGIVSIYLLVIPLILFYWMNNRWNVMGKFERLIVYGLVFLFFPGLILFSPFLNLRLRGDSKG,<ps2>,MESIFNNSFATLVAYVGIVSIYLLVIPLILFYWMNNRWNVMGKFERLIVYGLVFLFFPGLILFSPFLNLRLRGDSKG,<
+<ps1>,LTKGKVVQIGLLISLLGLLSYKLAPQLGIDNFTASTISNFVLIVIVISWVTSYVLRVLNGKMTFMEQRKRYRKEYEKIVNDKLETKFNLLPKEEQEKLMEDLEKNP,<ps2>,LTKGKVVQIGLLISLLGLLSYKLAPQLGIDNFTASTISNFVLIVIVISWVTSYVLRVLNGKMTFMEQRKRYRKEYEKIVNDKLETKFNLLPKEEQEKLMEDLEKNP,<
+<ps1>,MNDSYYKDKEKIYDAEVLESSSLDENIIIKILIRAGRTIAKPALEVLEMALDPFTPTQVRVSLMAALAYLIMPFDLFPDFMPLVGYSDDFVALTAVLSIWSRYMTPAIRARAERKLNKLFPFVK,<ps2>,MNDSYYKDKEKIYDAEVLESSSLDENIIIKILIRAGRTIAKPALEVLEMALDPFTPTQVRVSLMAALAYLIMPFDLFPDFMPLVGYSDDFVALTAVLSIWSRYMTPAIRARAERKLNKLFPFVK,<
+<ps1>,MLRSIFAGFFAIVLTLGLGISSVSAKTVEVKLGTDAGMLAFEPSSVTISTGDTVKFINNKLAPHNAVFDGHEELSHADLAFAPGESWEETFDTAGTFDYYCEPHRGAGMVGKVIVE,<ps2>,MKGHKKIRFIFPLVAMYVPLLLLAPKAIAGSFGAEIFCTMRDGGNDHESSWQAAYSYIKKQKGGIFKTSPKQAAGQIIETVVRERDKFSYCVEFLDQLHPDRKLQLENDRKEKRRKKEELLQDKENEDYSKETFDRYSY,<
+<ps1>,MLRSIFAGFFAIVLTLGLGISSVSAKTVEVKLGTDAGMLAFEPSSVTISTGDTVKFINNKLAPHNAVFDGHEELSHADLAFAPGESWEETFDTAGTFDYYCEPHRGAGMVGKVIVE,<ps2>,VQFIDQANIILKAGKGGNGIVSFRREKFVPAGGPSGGNGGKGGSIIIIADNNLQTLLDFKFNREIFAKDGFKGGPNKRSGASGENTILKVPCGTEIRDFNTGIILGDLTEDKQSLTIAHGGRGGHGNAYYLSNQNRAPESFTEGKEGEIWEVQLELKLLAEVGIIGLPNAGKSTLISVLSSARPKIANYPFTTLIPNLGVVRKADGNGCLFADIPGLISGAAEGVGLGHDFLRHIQRTKILIHLIDSIAENPIRDFEIIEKELKRYGSGLLNKERIVVLNKMELVDENYLQTITKKLENLSKKKVLVISSSLRKGLSPLLSEVWKRI,<
+<ps1>,MTNKKRILSGVQPTGDLHIGNWLGAINNWVELQEKHETFLCVVDLHAITTEYDTKQLSKNTLSTAALYIACGINPKICSIFVQSQISAHSELCWILNCMTPINWMERMIQFKEKSIQQGNNVSIGLFDYPILMAADILLYDADYVPVGEDQKQHLELAKDIAQQRINAKFGKEENILKIPQPIIMKKGSKIMSLNDGSKKMSKSDINEGSRINLLDTPEIITKKIKRAKSDSYMGMEFNNPERPESRNLLMIYSLLSGKEVSELENDLSQTGWGTFKKIFTEQIIESLKPIQERYQVLINDPHELNKILIQGKEKAEVVANKTLSRVKSELGFFEIEK,<ps2>,MTNKKRILSGVQPTGDLHIGNWLGAINNWVELQEKHETFLCVVDLHAITTEYDTKQLSKNTLSTAALYIACGINPKICSIFVQSQISAHSELCWILNCMTPINWMERMIQFKEKSIQQGNNVSIGLFDYPILMAADILLYDADYVPVGEDQKQHLELAKDIAQQRINAKFGKEENILKIPQPIIMKKGSKIMSLNDGSKKMSKSDINEGSRINLLDTPEIITKKIKRAKSDSYMGMEFNNPERPESRNLLMIYSLLSGKEVSELENDLSQTGWGTFKKIFTEQIIESLKPIQERYQVLINDPHELNKILIQGKEKAEVVANKTLSRVKSELGFFEIEK,<
+<ps1>,LGRSRKTNQLIREFLSELKEVLTKDGSITLRSLIFQENFHSLEGALKETEIKFIYPSDLKRFKDKSLNVLDICFGLGYNSASLFNNVIRQNSLINWYALEIDKKPLEYSLGNKSFQKLWHPKVFKILKALLKNSKYKDQFFDCDILWGDAREKIKNIPANIKFDLIYLDGFSPQKCPQVWSVEFLSKVTQKLNPQGYLITYSCSAAIRSTLKDFGLNIFNNKPNLVSKNLWSYGTIAVKNIDEKVLQNNLYLKKLSWMEEEHLLTKASIPYRDPTLNSNPKDIIKKRVQEQFLSNLKTSKKWRDKWGMTK,<ps2>,LGRSRKTNQLIREFLSELKEVLTKDGSITLRSLIFQENFHSLEGALKETEIKFIYPSDLKRFKDKSLNVLDICFGLGYNSASLFNNVIRQNSLINWYALEIDKKPLEYSLGNKSFQKLWHPKVFKILKALLKNSKYKDQFFDCDILWGDAREKIKNIPANIKFDLIYLDGFSPQKCPQVWSVEFLSKVTQKLNPQGYLITYSCSAAIRSTLKDFGLNIFNNKPNLVSKNLWSYGTIAVKNIDEKVLQNNLYLKKLSWMEEEHLLTKASIPYRDPTLNSNPKDIIKKRVQEQFLSNLKTSKKWRDKWGMTK,<
+<ps1>,LKNGADSIQVFSDLELLKKTAKKWDGNKRLMLAERGGKTIDGFDLGNSPLSVTKETVQGKRLFMSTTNGTKSLKKVQNVENLFAMSLPNRKAVAERIISLNKKNVLILGSGWEGSYSLEDSLAAGALAIYIKENFNSEVNILNDELQASLALWNVWKNDILKCLKTATHGKRLTSLGDYEDDFKCCSELDCLDIVPTQVERGVIRAS,<ps2>,LKNGADSIQVFSDLELLKKTAKKWDGNKRLMLAERGGKTIDGFDLGNSPLSVTKETVQGKRLFMSTTNGTKSLKKVQNVENLFAMSLPNRKAVAERIISLNKKNVLILGSGWEGSYSLEDSLAAGALAIYIKENFNSEVNILNDELQASLALWNVWKNDILKCLKTATHGKRLTSLGDYEDDFKCCSELDCLDIVPTQVERGVIRAS,<
+<ps1>,LISEIKELCLKANAIILAHYYQAPEIQDIADFIGDSLDLSRKAANNDADTIVFCGVHFMAETAKILSPNKTVLLPDIDAGCSLADDCPAEEFQKFREENPDHYVVSYINCTAEVKAQSDLICTSSNAVSLVEKIPKDKKIIFAPDKNLGRWVQKNSGRKLKLWPGSCIVHETFSEEALLKLKYKHPDAKVIAHPECSQNLLVLSDFIGSTSKLLDFVSNDYSDTYMVLTEPGIIHQMKKKEPNKNFIEVPDIDGCKCNECPYMKLNTLEKILDCLKNNSPSIELDPEIIKKAYKPIKRMLDMSI,<ps2>,LISEIKELCLKANAIILAHYYQAPEIQDIADFIGDSLDLSRKAANNDADTIVFCGVHFMAETAKILSPNKTVLLPDIDAGCSLADDCPAEEFQKFREENPDHYVVSYINCTAEVKAQSDLICTSSNAVSLVEKIPKDKKIIFAPDKNLGRWVQKNSGRKLKLWPGSCIVHETFSEEALLKLKYKHPDAKVIAHPECSQNLLVLSDFIGSTSKLLDFVSNDYSDTYMVLTEPGIIHQMKKKEPNKNFIEVPDIDGCKCNECPYMKLNTLEKILDCLKNNSPSIELDPEIIKKAYKPIKRMLDMSI,<
+<ps1>,MNRKSNNSNPTGNLDYDKILEEEIINSYENKFEANSNINNKNKRFYRLKRTPLEVINRLFFFFFVGSFIFSFFLAYSENKVWFIIYLISAFSCIFYTPNRKALKELIAAWPNIEDLIKGRSLWRKDNK,<ps2>,MNRKSNNSNPTGNLDYDKILEEEIINSYENKFEANSNINNKNKRFYRLKRTPLEVINRLFFFFFVGSFIFSFFLAYSENKVWFIIYLISAFSCIFYTPNRKALKELIAAWPNIEDLIKGRSLWRKDNK,<
+<ps1>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<ps2>,VSGWLFIIFLLLLGGLISTLGDLLGSKIGKARFSILKLRPKKTAILITILTGSLISASSLFLMILVNRQLRVGLFRLGDLQKKLQESKQVLIPLEKEREKLENKIKAKETEFKQLERNIIALRSGKFVIRSGQSLIISEISSSNLKDIKSKIEKIIINANRYTHKIVKPKNKEVKNLLLLRKNHIEEMQNIILKGGNWVINIKSVRNVLTGENFVYAFPEITENKIIVRKGEKITKIDFKQEDFNKKDFGDKVNFLLSSSLAEIKRRGSLVNEIKLRGDSIKELRDFLNKNDKTNFELEAVSLFNSKTAQPVIVELNVNYPES,<
+<ps1>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<ps2>,LGRSRKTNQLIREFLSELKEVLTKDGSITLRSLIFQENFHSLEGALKETEIKFIYPSDLKRFKDKSLNVLDICFGLGYNSASLFNNVIRQNSLINWYALEIDKKPLEYSLGNKSFQKLWHPKVFKILKALLKNSKYKDQFFDCDILWGDAREKIKNIPANIKFDLIYLDGFSPQKCPQVWSVEFLSKVTQKLNPQGYLITYSCSAAIRSTLKDFGLNIFNNKPNLVSKNLWSYGTIAVKNIDEKVLQNNLYLKKLSWMEEEHLLTKASIPYRDPTLNSNPKDIIKKRVQEQFLSNLKTSKKWRDKWGMTK,<
+<ps1>,MSIAKKALLFTSALALIAGPSVTASTRLSGAGASFPAKIYTRWFSDLAKSGGPRVNYQAVGSGSGRKAFIDQTVNFGASDDPMKDKDIAKVTRGLVQIPMVGGTIAFGYNYDCDLKLTQEQAVQVAMGMVKNWKELGCKAGKLTWAHRSDGSGTTKAFTNSMEAFSPTWTLGTGKSVKWPAGVGAKGNSGVAGVIQNTPGAIGYVNQSYIKGNVKAAALQNLSGEFLKPSVEAGAKALNGITLDENLAGKNPNPTAKGAYPIASLTWILAYEKGNGRNTKAIKKSLSTLLSDEYQDKAPTLGFVPLKGDILEKSRAAVKKIGR,<ps2>,MSIAKKALLFTSALALIAGPSVTASTRLSGAGASFPAKIYTRWFSDLAKSGGPRVNYQAVGSGSGRKAFIDQTVNFGASDDPMKDKDIAKVTRGLVQIPMVGGTIAFGYNYDCDLKLTQEQAVQVAMGMVKNWKELGCKAGKLTWAHRSDGSGTTKAFTNSMEAFSPTWTLGTGKSVKWPAGVGAKGNSGVAGVIQNTPGAIGYVNQSYIKGNVKAAALQNLSGEFLKPSVEAGAKALNGITLDENLAGKNPNPTAKGAYPIASLTWILAYEKGNGRNTKAIKKSLSTLLSDEYQDKAPTLGFVPLKGDILEKSRAAVKKIGR,<
+<ps1>,MKIGINGFGRIGRLVFRALWDRADTEITHINEMAGDSNAAAHLLEFDSVHGRWVKDIKVKEEEIIIDGKKLAYTSFKNYLDVPWEKSSVDIILECTGKNKKPDKLNPYFDSLGMKRVIVACPVKGIVAEAESLNIVYGINQNLYDPSKHKLVTAASCTTNCLAPIVKVINENFSIKHGAITTIHDVTNTQVPVDFYKSDLRRARGCMQSLIPTTTGSAKAIAEIFPELKGKLNGHAVRVPLLNGSLTDAVFELNNAVTEEQVNNEFKKASETYLEGILGYEERPLVSADYVNDSRSSIVDSLSTMVVNSNLLKIYAWYDNEWGYSCRLADLTEYVIKKEI,<ps2>,MKIGINGFGRIGRLVFRALWDRADTEITHINEMAGDSNAAAHLLEFDSVHGRWVKDIKVKEEEIIIDGKKLAYTSFKNYLDVPWEKSSVDIILECTGKNKKPDKLNPYFDSLGMKRVIVACPVKGIVAEAESLNIVYGINQNLYDPSKHKLVTAASCTTNCLAPIVKVINENFSIKHGAITTIHDVTNTQVPVDFYKSDLRRARGCMQSLIPTTTGSAKAIAEIFPELKGKLNGHAVRVPLLNGSLTDAVFELNNAVTEEQVNNEFKKASETYLEGILGYEERPLVSADYVNDSRSSIVDSLSTMVVNSNLLKIYAWYDNEWGYSCRLADLTEYVIKKEI,<
+<ps1>,MKNSIKITQLFLLLIFLTSCKATANKQELIIDSEEQESQQTKLSKSKMEVRYSCGEDGISDFLNDGWIISKQYTEEKICTWKSFPATKDCDMEKDKGCKITTPDKIGEEKVYLLEK,<ps2>,MKNSIKITQLFLLLIFLTSCKATANKQELIIDSEEQESQQTKLSKSKMEVRYSCGEDGISDFLNDGWIISKQYTEEKICTWKSFPATKDCDMEKDKGCKITTPDKIGEEKVYLLEK,<
+<ps1>,MNFEIKNVFLTIEGKSIVNDVSIKVCPGEIVGLMGPNGAGKTSTFNLAVGNLRPDKGDILINSKSIKNLPLPIRAKLGLGYLTQEASIFRDLTVKENIDLALENSFSSRAIVRNKREKIINEFNLNKVVDNYGYQLSGGERRRCEIARALSVGRQGPKYLLLDEPFAGIDPLAVNDLKKLIIKLRDNGMGILITDHNVRETLLITSKSYVLSEGKILAHGSSDELANNQIVKKFYLGVDFQL,<ps2>,MAAKEHKSLQGSKILLIEDDKSIRLTVTESLISEGFEVSNFKDGSSALDFILGEGIKDFDLILLDLMLPGLNGLELCRKIRNEELYTPILILSAKGNESDRVLGLEVGADDYLTKPFGISELIARCRALLRRSKRGKEKKQKIETIIEYKNIKMFTEECRVTNFNQEIILSPKEFKLLELFIKNPKRVWSRDLILEKIWAIDFIGDTKTVDVHVRWLREKLEENPSAPKIIKTVRGFGYRFG,<
+<ps1>,MNFEIKNVFLTIEGKSIVNDVSIKVCPGEIVGLMGPNGAGKTSTFNLAVGNLRPDKGDILINSKSIKNLPLPIRAKLGLGYLTQEASIFRDLTVKENIDLALENSFSSRAIVRNKREKIINEFNLNKVVDNYGYQLSGGERRRCEIARALSVGRQGPKYLLLDEPFAGIDPLAVNDLKKLIIKLRDNGMGILITDHNVRETLLITSKSYVLSEGKILAHGSSDELANNQIVKKFYLGVDFQL,<ps2>,MNFEIKNVFLTIEGKSIVNDVSIKVCPGEIVGLMGPNGAGKTSTFNLAVGNLRPDKGDILINSKSIKNLPLPIRAKLGLGYLTQEASIFRDLTVKENIDLALENSFSSRAIVRNKREKIINEFNLNKVVDNYGYQLSGGERRRCEIARALSVGRQGPKYLLLDEPFAGIDPLAVNDLKKLIIKLRDNGMGILITDHNVRETLLITSKSYVLSEGKILAHGSSDELANNQIVKKFYLGVDFQL,<
+<ps1>,MLLSKLVDLIKSGESKFIKANIFENIDIENAASIDIALKNQISFLEENNILKDNLGKTSASAIITSNNNEILGLLESLNISNIVVENPRIAFAEVLNFLYEEINFNPGIDDSAVIKSSAKVGKNCYVGPNVYIGENSIIGDNNKIFPGTTILGNVRLGNNNVIHPNCVIYENTSIENNCVINSNTVIGSEGFGFIPQDGKWIKMPQKGCVIIKSFVEIGTNCCIDRPSVGNTFIDEGTKMDNLVQIGHGVKIGKNCAFAAQVGIAGGAVIGNSVILAGQVGVNNRVKVGNNVIASSKCGIHCDIEDGEVVSGFPAMKNKSWLRSSSVFKKLPELAKKLRQLDKK,<ps2>,MLLSKLVDLIKSGESKFIKANIFENIDIENAASIDIALKNQISFLEENNILKDNLGKTSASAIITSNNNEILGLLESLNISNIVVENPRIAFAEVLNFLYEEINFNPGIDDSAVIKSSAKVGKNCYVGPNVYIGENSIIGDNNKIFPGTTILGNVRLGNNNVIHPNCVIYENTSIENNCVINSNTVIGSEGFGFIPQDGKWIKMPQKGCVIIKSFVEIGTNCCIDRPSVGNTFIDEGTKMDNLVQIGHGVKIGKNCAFAAQVGIAGGAVIGNSVILAGQVGVNNRVKVGNNVIASSKCGIHCDIEDGEVVSGFPAMKNKSWLRSSSVFKKLPELAKKLRQLDKK,<
+<ps1>,MSSNFKNLYTSNNPPLEMILMRGSKLESIHKVHAVISDKKGRVLMCAGNPEYKSFIRSALKPFQAIPFVSSGASSKIKNSSKSIALSCGSHSGSKLHAREAFKILWEYNIDIHNLKCPIKKTSPLEHNCSGKHAAFLATCKKLNWPLETYLKGDHPLQVEIFRIISELLEIPLEQIYAERDDCGAPTLYMKILEMAKLYSLLSSSDNAELEQISRAMTINPTMISDHNRFDTEVIQASHGHVISKGGAEGIQCFCKVNEGMGLALKVEDGSKRAKQSVGLHILKQLEWISELRIQDIEDKIIKLPEGVQIEVKGQLKFQES,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,VRIIFWGTPEYSVKSLEVLKKSDHDIVAVITQPDKKRSRGNKLISSPVKEYATKENIPVFTPETIKENIQFISILNDLSCDLFIVIAYGKILPKAILDIPKYKSWNAHASLLPRWRGAAPIQWSILEGDKITGVGIMRMEEGLDTGDVLVEKQIKIENNDNLKTLTKKLSDLSSELFLRAISDIEQNKNRDINLLLKKQTDFKRELKYARMINKLDYIINWENSATDIYRKINALYPRANTTYKRKNLKIIKIKILTTHEIHNKNYKILSNVFKPGLIIGLIKNVGIIITTKTDPILLLEAKLEGKKVSSQNQLIQQLNPVIGENFSD,<ps2>,VRIIFWGTPEYSVKSLEVLKKSDHDIVAVITQPDKKRSRGNKLISSPVKEYATKENIPVFTPETIKENIQFISILNDLSCDLFIVIAYGKILPKAILDIPKYKSWNAHASLLPRWRGAAPIQWSILEGDKITGVGIMRMEEGLDTGDVLVEKQIKIENNDNLKTLTKKLSDLSSELFLRAISDIEQNKNRDINLLLKKQTDFKRELKYARMINKLDYIINWENSATDIYRKINALYPRANTTYKRKNLKIIKIKILTTHEIHNKNYKILSNVFKPGLIIGLIKNVGIIITTKTDPILLLEAKLEGKKVSSQNQLIQQLNPVIGENFSD,<
+<ps1>,MRNEKYWVKALDQTHLSITNNGLFPLKTTVVTREYYNKNDFIIRELDTSRFTKKNNYGPNQNPFNPWDKILEVDKVGTNHQLILNKYPVQKGHILLITNTWRPQDGWLDINDWIAIQMVNEDTSGLWFFNSSPIAGASQPHRHFQLLRRDHGEIICPREKWFLDFENNNDQDSKLKKNTVVSKFNFLNNSINIYNLYLELSNKIGLGNPIDDEKPRFPYNILITNNWIAIIKRKYDHVHGFSVNGLGFAGYLLVTEKSNINYLKKYGPEKLLENFV,<ps2>,MRNEKYWVKALDQTHLSITNNGLFPLKTTVVTREYYNKNDFIIRELDTSRFTKKNNYGPNQNPFNPWDKILEVDKVGTNHQLILNKYPVQKGHILLITNTWRPQDGWLDINDWIAIQMVNEDTSGLWFFNSSPIAGASQPHRHFQLLRRDHGEIICPREKWFLDFENNNDQDSKLKKNTVVSKFNFLNNSINIYNLYLELSNKIGLGNPIDDEKPRFPYNILITNNWIAIIKRKYDHVHGFSVNGLGFAGYLLVTEKSNINYLKKYGPEKLLENFV,<
+<ps1>,MTTSSKKDYLSILGLSSKFDDIELKKAFRREARKWHPDLNKNDINAEDRFKLINEAYEFLRDPVRRVKSIDSNSSNEEIYNKYSTGFPEFKDYLNSLFGFEYESELDNESYDQTSDFYEDEKPNAIFNEEEFNSYDYPARSPEEPPPVKLHQDIETIIELTPDEALSGASILIELEDQTVVEVDTPPFAGDGWRLRLENIAKGGKDHYLQLKVQTENGLRIDGLRVLYKLELFPPDALLGCAVEVPTLDGNVTLQVPPKSSTGRLLRLKGRGLSFGDNIGDQFVEILVVIPADINDEEIALYTRLQELSLSDE,<ps2>,MTTSSKKDYLSILGLSSKFDDIELKKAFRREARKWHPDLNKNDINAEDRFKLINEAYEFLRDPVRRVKSIDSNSSNEEIYNKYSTGFPEFKDYLNSLFGFEYESELDNESYDQTSDFYEDEKPNAIFNEEEFNSYDYPARSPEEPPPVKLHQDIETIIELTPDEALSGASILIELEDQTVVEVDTPPFAGDGWRLRLENIAKGGKDHYLQLKVQTENGLRIDGLRVLYKLELFPPDALLGCAVEVPTLDGNVTLQVPPKSSTGRLLRLKGRGLSFGDNIGDQFVEILVVIPADINDEEIALYTRLQELSLSDE,<
+<ps1>,LKKTFKVTITNKETGKIYQENISDQEYILKEFEKKGLRLPFSCRNGCCTSCAVKIISGKLDQPEAMGVSQDLKDKGYALLCVAKVIEDIEVETTYYDEVYDLQFGQYFGKGKTRKAPPWEFEED,<ps2>,MKGHKKIRFIFPLVAMYVPLLLLAPKAIAGSFGAEIFCTMRDGGNDHESSWQAAYSYIKKQKGGIFKTSPKQAAGQIIETVVRERDKFSYCVEFLDQLHPDRKLQLENDRKEKRRKKEELLQDKENEDYSKETFDRYSY,<
+<ps1>,MDFKTYQKQARLTAQYPNLGSNNIYPTLGLVGEAGEVAEKVKKVIRDKKGIFDEESKKGIKKELGDVLWYISNLCNEFNFELEEVALQNLEKLKLRAAKGKISGSGDDR,<ps2>,MDFKTYQKQARLTAQYPNLGSNNIYPTLGLVGEAGEVAEKVKKVIRDKKGIFDEESKKGIKKELGDVLWYISNLCNEFNFELEEVALQNLEKLKLRAAKGKISGSGDDR,<
+<ps1>,MSFFQGKILLNFIIDLLNKPAINWSNFELNSSLQLNDFVDLLLEPLNTSQYSYNIKLGLHEALINAVTHGNKLDPNKSIRVRRIITPNWCVWQIQDQGNGLEIKKRLYKLPKKFTSFNGRGLYIINECFDDIRWSNKGNRLQLALKR,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,MSFFQGKILLNFIIDLLNKPAINWSNFELNSSLQLNDFVDLLLEPLNTSQYSYNIKLGLHEALINAVTHGNKLDPNKSIRVRRIITPNWCVWQIQDQGNGLEIKKRLYKLPKKFTSFNGRGLYIINECFDDIRWSNKGNRLQLALKR,<ps2>,MSFFQGKILLNFIIDLLNKPAINWSNFELNSSLQLNDFVDLLLEPLNTSQYSYNIKLGLHEALINAVTHGNKLDPNKSIRVRRIITPNWCVWQIQDQGNGLEIKKRLYKLPKKFTSFNGRGLYIINECFDDIRWSNKGNRLQLALKR,<
+<ps1>,VASTLLFTALKEAIDEEMANDVNVCIMGEDVGQYGGSYKVTKDLYEKYGELRVLDTPIAENSFTGMAVGAAMTGLRPIVEGMNMGFLLLAFNQISNNMGMLRYTSGGNYKIPAVVRGPGGVGRQLGAEHSQRLEAYFHAVPGIKIVACSTPTNAKGLMKAAIRDNNPVLFFEHVLLYNLSEELPEGDYICSLDQADLVKEGKDITILTYSRMRHHCLKAVEELDKKNIDVELIDLISLKPFDMKTISKSIKKTNNVIIVEECMKTGGIGAELIALITEECFDDLDTRPIRLSSQDIPTPYNGNLENLTIIQPHQIVEKVEEVINGSI,<ps2>,VASTLLFTALKEAIDEEMANDVNVCIMGEDVGQYGGSYKVTKDLYEKYGELRVLDTPIAENSFTGMAVGAAMTGLRPIVEGMNMGFLLLAFNQISNNMGMLRYTSGGNYKIPAVVRGPGGVGRQLGAEHSQRLEAYFHAVPGIKIVACSTPTNAKGLMKAAIRDNNPVLFFEHVLLYNLSEELPEGDYICSLDQADLVKEGKDITILTYSRMRHHCLKAVEELDKKNIDVELIDLISLKPFDMKTISKSIKKTNNVIIVEECMKTGGIGAELIALITEECFDDLDTRPIRLSSQDIPTPYNGNLENLTIIQPHQIVEKVEEVINGSI,<
+<ps1>,MSKLSTTKICVKSPAKINLHLEIIGKRKDGYHELAMIMQNIDLSDYIEFENNQIGEIKLKSNSKDLSLDEDNLIIKAANYIKDMSKNKELGANIFLKKNIPIGAGLAGGSSNAAATLVGLNKLWDLDLDYETIFILSAKLGSDVPFFIEGGCQFCFGRGEILEKYSSNFDFGVILLKNPNISISTVDTYKKYSQEFCPKYFTETEKTNKIRNDLRVNGFNDFKLSEQRINVKNDLQVIVERENNSVKKALYLLSNLQNCLSYSMSGSGPTCFALFKDINIANEVFEQNYKMFNNNGFEAWVCKLINSGITLL,<ps2>,LVKPKSPDNKISNHLQQDVVKIAGKTIFINPFLYWRRFDENTNRWLREPGQMSEEQIQPNRNRFYPEIDWADLSQNQKLVKDASVEMFLKTLELISTFHPQLNSGQLLEVERKMAITKKLPFEKWVTKSFAKKARAEEYEKRKFKRDRFIRSWKEWLSLENTQQALLPIIVVVFVSAFIGWSSGVSKNSCNPYFEQNLDQSI,<
+<ps1>,MSKLSTTKICVKSPAKINLHLEIIGKRKDGYHELAMIMQNIDLSDYIEFENNQIGEIKLKSNSKDLSLDEDNLIIKAANYIKDMSKNKELGANIFLKKNIPIGAGLAGGSSNAAATLVGLNKLWDLDLDYETIFILSAKLGSDVPFFIEGGCQFCFGRGEILEKYSSNFDFGVILLKNPNISISTVDTYKKYSQEFCPKYFTETEKTNKIRNDLRVNGFNDFKLSEQRINVKNDLQVIVERENNSVKKALYLLSNLQNCLSYSMSGSGPTCFALFKDINIANEVFEQNYKMFNNNGFEAWVCKLINSGITLL,<ps2>,VPNNQNRDNFIDKAFTVIAESIVKIMPIADKEKKAYIYYRDGLAAQNNGDYSEALDYYNESLLLEENKIDRGETLKNMAIIYMSNGEEDRSIETYQKALEENPKQPSCLKNIGLIYEKRGRFAEQNGDLDQRDMWFDKAAQVWSKAVRLYPGGYLDIENWLKTSGRSSIDIYL,<
+<ps1>,MKNLKLKVIFKYLKPYKKEFLYGGIALLVVNILSILIPLEVKNIIDQLKDGFSSSFVISKSLFLMFLATCMGLIRLFSRQIVFGIGRKVEVNLRQKLFDHLLIQDPDWIQKKGSGDIISRATSDVENIRRLLGFTVLSLCNIVLAYSLTIPSMLSINKTLTVAALMIFPMILVIVSLFGGRMVSQRKIQQESLSKLSDLIQEDLSGISAIKIYAQEEAEKKQFNNYNKVYRNSAIKLARTASTLFPLLQGISSISLLILLGLGTSQLENGFITIGGLVALILFVERLVFPTALLGFTLNTFQLGQVSLDRVEEIFQNNPKITDKPKAKFIKKKVKGTIEAKNLKIKYEGAKFNSLNRLNFKINPGELIAIVGPVGCGKTTLAKSLGRTIEIPDGQLFLDDIDITNIKLRDLRKHIAIVPQEAFLFTSTISENLKFGDPKASRNVVKNSAVNAGLIDDINSFPDGFKTIVGERGITLSGGQRQRTALGRALLVDASVVVLDDALASVDNKTAAKIIEEMRANKSKTILMISHQLSVAATCDRVLVMDQGKIVQEGIHKDLITTNGLYKNLWEREIATNKIVS,<ps2>,MKNLKLKVIFKYLKPYKKEFLYGGIALLVVNILSILIPLEVKNIIDQLKDGFSSSFVISKSLFLMFLATCMGLIRLFSRQIVFGIGRKVEVNLRQKLFDHLLIQDPDWIQKKGSGDIISRATSDVENIRRLLGFTVLSLCNIVLAYSLTIPSMLSINKTLTVAALMIFPMILVIVSLFGGRMVSQRKIQQESLSKLSDLIQEDLSGISAIKIYAQEEAEKKQFNNYNKVYRNSAIKLARTASTLFPLLQGISSISLLILLGLGTSQLENGFITIGGLVALILFVERLVFPTALLGFTLNTFQLGQVSLDRVEEIFQNNPKITDKPKAKFIKKKVKGTIEAKNLKIKYEGAKFNSLNRLNFKINPGELIAIVGPVGCGKTTLAKSLGRTIEIPDGQLFLDDIDITNIKLRDLRKHIAIVPQEAFLFTSTISENLKFGDPKASRNVVKNSAVNAGLIDDINSFPDGFKTIVGERGITLSGGQRQRTALGRALLVDASVVVLDDALASVDNKTAAKIIEEMRANKSKTILMISHQLSVAATCDRVLVMDQGKIVQEGIHKDLITTNGLYKNLWEREIATNKIVS,<
+<ps1>,MAKSSWEGNCFLNFFNNKSSSGKDDKTIFKSKFTSPYKLLKCSYDQEGRCILPILHTAGGLVGGDLLEFEANIGINSKVLLTTSSAQKVYGSVGRSKINPEGTFSSQKTKISILDNSHLEYLPQETIVFANGLYSQEFNIKISDNSSFLFTDLIRLGRSSAGESIESGVFRSKLEIMRNGNLCDDWEFVDQIELTKFSFEAKSGMDFKPVFGSLIWICEKEFPITKISYLKEKIKIIFKENNNYLSLGTLENGLSIRFLGTSSQDARKCFFSIWTQIRTVCGFCKPEYQGVWPLQDL,<ps2>,MAKSSWEGNCFLNFFNNKSSSGKDDKTIFKSKFTSPYKLLKCSYDQEGRCILPILHTAGGLVGGDLLEFEANIGINSKVLLTTSSAQKVYGSVGRSKINPEGTFSSQKTKISILDNSHLEYLPQETIVFANGLYSQEFNIKISDNSSFLFTDLIRLGRSSAGESIESGVFRSKLEIMRNGNLCDDWEFVDQIELTKFSFEAKSGMDFKPVFGSLIWICEKEFPITKISYLKEKIKIIFKENNNYLSLGTLENGLSIRFLGTSSQDARKCFFSIWTQIRTVCGFCKPEYQGVWPLQDL,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,VNSNSSNQVGKNIRRTGFLIVLSYLLIVLIMKVLEANNFFGYSLSSFSNDIFAPPSLKHLCGTDRLGRDVCLRTLQGSSIAIEVVFLAIFFALILGLPLGLLSGYFGGILDKCLSLVMDTIFSIPVILLAVVVAFVLGKGIINASIALCIVYSPQYFRLIRNQTMLIKSETYVEAARVSGADVKTIIFKYILPNVITPLPILLTLNAADAVLVLGSLGFLGLGVPANVPEWGSDLNLALAAIPTGIWWTALFPGLAMFFLVLGLSFIGEELENIFEN,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,MTKFKLKIASRRSKLAMVQTLWVKEQLEKNIPDLEVSIEAMATQGDKILDVALAKIGDKGLFTKELEAQMLVGHADIAVHSLKDLPTNLPDGLTLGCITKREDPSDALVVNKKNKIYQLESLPPGSIVGTSSLRRLAQLRYKFPHLDFKDIRGNVITRIEKLDSGEFDCIILAAAGLKRLGFESRVHQIIPNEISLHAVGQGALGIECKSDDKEVLKIISVLEDKVSSQRCLAERSFLRELEGGCQVPIGVNSSIQNDEIALIGMVASIDGKRLIKNESIGNIKYPEEVGKKLAEKLKLQGADKILSEIFEQFRDK,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,LGRSRKTNQLIREFLSELKEVLTKDGSITLRSLIFQENFHSLEGALKETEIKFIYPSDLKRFKDKSLNVLDICFGLGYNSASLFNNVIRQNSLINWYALEIDKKPLEYSLGNKSFQKLWHPKVFKILKALLKNSKYKDQFFDCDILWGDAREKIKNIPANIKFDLIYLDGFSPQKCPQVWSVEFLSKVTQKLNPQGYLITYSCSAAIRSTLKDFGLNIFNNKPNLVSKNLWSYGTIAVKNIDEKVLQNNLYLKKLSWMEEEHLLTKASIPYRDPTLNSNPKDIIKKRVQEQFLSNLKTSKKWRDKWGMTK,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,MIDSFPLIKKEHIETLQINIGLKCNQACKHCHVNSSPLRSEKMSYEIISLIPKVIEKYKIKTLDITGGAPEMHPEFRNLITTLSDKNIDIIDRCNLTIFFEDGFEDLPQFLAKNNVIVTASLPCYEKDNVELQRGYGVFDKSINALKILNDLGYGKQKDGLQLNLVYNPVNPILPPSQVILKEDYKRILFEKYNISFNNLYTITNMPINRYADSLNSENKLDSYYKLLKENFNKNNLEKLMCKKTISVNWQGQIYDCDFNQQINLKGNKGPKTLSDLMSKSFKFDYGVAVKEHCFACTAGAGSSCGGTLT,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,MQKTKFSKINDQFNNLLFGFLSSSWKSKSINVISVLTGYFLFANFATKFISEGKNELIMVPIIILIIELIIRIRPPAGSSFFNLWSIIDKARIGATYAVILEAFKLGS,<
+<ps1>,MSSKLRVGVAGPVGSGKTALVETLCIALKKRYKIAVVTNDIYTKEDANFLIKKKILEEGRIVGVETGGCPHTAIREDCSLNKNAVMDLENKYDPLDFIFVESGGDNLAASFSPELVDLSIYVIDVSAGDKIPRKGGPGITRSDLLLINKIDLADMVGANLNIMQNDTNMMRDGKPWFFTNLSSGSGVDNVIKYLVAQIPNI,<ps2>,MSKLSTTKICVKSPAKINLHLEIIGKRKDGYHELAMIMQNIDLSDYIEFENNQIGEIKLKSNSKDLSLDEDNLIIKAANYIKDMSKNKELGANIFLKKNIPIGAGLAGGSSNAAATLVGLNKLWDLDLDYETIFILSAKLGSDVPFFIEGGCQFCFGRGEILEKYSSNFDFGVILLKNPNISISTVDTYKKYSQEFCPKYFTETEKTNKIRNDLRVNGFNDFKLSEQRINVKNDLQVIVERENNSVKKALYLLSNLQNCLSYSMSGSGPTCFALFKDINIANEVFEQNYKMFNNNGFEAWVCKLINSGITLL,<
+<ps1>,LSRLLISFIFFAIVFLSPLSTFASHTSDPTVSLLQSRISKNFSKKFCNAIQNGLSKDEAMTSAIVKTENIVSFSYNPQKKWIEKEDLANQISIKVINDCGWSFGLIGKEGIDYFNSYFLEIYDKTTPDKKLSS,<ps2>,LSRLLISFIFFAIVFLSPLSTFASHTSDPTVSLLQSRISKNFSKKFCNAIQNGLSKDEAMTSAIVKTENIVSFSYNPQKKWIEKEDLANQISIKVINDCGWSFGLIGKEGIDYFNSYFLEIYDKTTPDKKLSS,<
+<ps1>,MTFEAKYLGSNGWLIKFDKTNLIIDPWLTGDLIFPPGEWFFKGSLDNEILIEEDINIILLTQGLPDHCHVPSLKKFKKDIDIICSNSAKGILEKLGFTSIKVLKPKEKIMQKELEIEATAGAPVPQIENGYIVKDYKGKGFYIEPHGYLDENVNSQELDAVITPIINLELPLVGSFVKGADVLPKLIKTFNPKYILSSTAGGEAKYTGLLNKFISVQEYAEEVKCNLVNLKTMDSVKI,<ps2>,MTFEAKYLGSNGWLIKFDKTNLIIDPWLTGDLIFPPGEWFFKGSLDNEILIEEDINIILLTQGLPDHCHVPSLKKFKKDIDIICSNSAKGILEKLGFTSIKVLKPKEKIMQKELEIEATAGAPVPQIENGYIVKDYKGKGFYIEPHGYLDENVNSQELDAVITPIINLELPLVGSFVKGADVLPKLIKTFNPKYILSSTAGGEAKYTGLLNKFISVQEYAEEVKCNLVNLKTMDSVKI,<
+<ps1>,MPIVFAWSLCLSVVVVLLSTIPLTLGRIKAGYSVENMSAPRALFDKLPDFGKRAVWCHQNCWESISIHAPACILCLITLPDSNLSLIAAWMHPLLRFLYIGAYVLNIPIARGLIWASGIFTTLVLYKEGISQFM,<ps2>,MPIVFAWSLCLSVVVVLLSTIPLTLGRIKAGYSVENMSAPRALFDKLPDFGKRAVWCHQNCWESISIHAPACILCLITLPDSNLSLIAAWMHPLLRFLYIGAYVLNIPIARGLIWASGIFTTLVLYKEGISQFM,<
+<ps1>,MTDIEEIKKKIYQIAAITDRGQRLNKLIAPMYQEKLKEMGNLIDILESFNTEVSEEKLSGEWELIYSTVELFRSSPFFLAIEKALNDEFKSNLFFKLHQLQVGSFGLSTIGRIAQNIDFDKKEFLSTFDTTIFGLTIIPILGWFKLLPTFGGRVITLADDLILEDKVLKMNLKKTKVSKVDGLNKIPLFSTLLMERWYPVKEVWEKLPWNKESPSCEVSVIYLDEEVRVMKDIYGSTFVYIRPTISLLNSK,<ps2>,MTDIEEIKKKIYQIAAITDRGQRLNKLIAPMYQEKLKEMGNLIDILESFNTEVSEEKLSGEWELIYSTVELFRSSPFFLAIEKALNDEFKSNLFFKLHQLQVGSFGLSTIGRIAQNIDFDKKEFLSTFDTTIFGLTIIPILGWFKLLPTFGGRVITLADDLILEDKVLKMNLKKTKVSKVDGLNKIPLFSTLLMERWYPVKEVWEKLPWNKESPSCEVSVIYLDEEVRVMKDIYGSTFVYIRPTISLLNSK,<
+<ps1>,MLLSRVAESLYWINRYLERAENISRFVEVSEAMSLDCPPGSAEPWLPLIDASSDRETFDSRFPEKKQDDVINFLIRDRINPNSIISCIQLARENARQIRDVMTSEMWEQINILYWNLQEGESIWDLPRQEQLSEIRRGCQLFYGITDATLSKDLACQFSILGRLIERADKTSRILDVKYYLLLPSLDELGGVLDELQWIALLRSAGAYQMFRKAEQNSIQPNSVARFLLLDNNFPRSVRYCLDGISNTLKMIDTSPSSDNPSKLECMRGLLKAKWSYIRIEDIINDGLHEAIDSLQIDLNKLHNLIEDKYFINKEFDQ,<ps2>,LVKPKSPDNKISNHLQQDVVKIAGKTIFINPFLYWRRFDENTNRWLREPGQMSEEQIQPNRNRFYPEIDWADLSQNQKLVKDASVEMFLKTLELISTFHPQLNSGQLLEVERKMAITKKLPFEKWVTKSFAKKARAEEYEKRKFKRDRFIRSWKEWLSLENTQQALLPIIVVVFVSAFIGWSSGVSKNSCNPYFEQNLDQSI,<
+<ps1>,MLLSRVAESLYWINRYLERAENISRFVEVSEAMSLDCPPGSAEPWLPLIDASSDRETFDSRFPEKKQDDVINFLIRDRINPNSIISCIQLARENARQIRDVMTSEMWEQINILYWNLQEGESIWDLPRQEQLSEIRRGCQLFYGITDATLSKDLACQFSILGRLIERADKTSRILDVKYYLLLPSLDELGGVLDELQWIALLRSAGAYQMFRKAEQNSIQPNSVARFLLLDNNFPRSVRYCLDGISNTLKMIDTSPSSDNPSKLECMRGLLKAKWSYIRIEDIINDGLHEAIDSLQIDLNKLHNLIEDKYFINKEFDQ,<ps2>,MKLRLFEFYFIKDYLRPWFGLIYSLFFLFFLGAIGYRITEGWDWGDCLWMVLITITTIGFGEVQTLSPEGRIITVLIIVGGLIFIQFTFQKAVRLFESGYFQRVNELRFKRLLRKMENHVILCGYGRVGQEISNQIKTQNIPIIVVESDEDRKKIAEDNGLEVLCADATLDETLKLAGLDKCKSLVVTLPNDAANLYVVLSAKGIRSSIRVIARAGTEEAASKLRLAGASIVVSPYIAAGRAMASMALRPIAIDFLDLLAGSECEIEEFELSNDISLFETAEKITLLELGIGKKSGAKILAIKEDEKLITNPGGDFLLQPGQVLIAFGSKEQLTTLNRLLGNLVVSVELLK,<
+<ps1>,MLLSRVAESLYWINRYLERAENISRFVEVSEAMSLDCPPGSAEPWLPLIDASSDRETFDSRFPEKKQDDVINFLIRDRINPNSIISCIQLARENARQIRDVMTSEMWEQINILYWNLQEGESIWDLPRQEQLSEIRRGCQLFYGITDATLSKDLACQFSILGRLIERADKTSRILDVKYYLLLPSLDELGGVLDELQWIALLRSAGAYQMFRKAEQNSIQPNSVARFLLLDNNFPRSVRYCLDGISNTLKMIDTSPSSDNPSKLECMRGLLKAKWSYIRIEDIINDGLHEAIDSLQIDLNKLHNLIEDKYFINKEFDQ,<ps2>,MSKLSTTKICVKSPAKINLHLEIIGKRKDGYHELAMIMQNIDLSDYIEFENNQIGEIKLKSNSKDLSLDEDNLIIKAANYIKDMSKNKELGANIFLKKNIPIGAGLAGGSSNAAATLVGLNKLWDLDLDYETIFILSAKLGSDVPFFIEGGCQFCFGRGEILEKYSSNFDFGVILLKNPNISISTVDTYKKYSQEFCPKYFTETEKTNKIRNDLRVNGFNDFKLSEQRINVKNDLQVIVERENNSVKKALYLLSNLQNCLSYSMSGSGPTCFALFKDINIANEVFEQNYKMFNNNGFEAWVCKLINSGITLL,<
+<ps1>,MTEVINNIPDFEKYLTDTKKVVEEALDFSLGPENPEILRESMRYSLLAGGKRIRPILCLASCSLAGGEPSLAVPTAVAIEMIHTMSLIHDDLPAMDNDGFRRGRPTNHKVYGDAIAILAGDALLTRAFEMVSLRSPGVDSNRLLNVVGELSLVAGAPGLVGGQVVDLECEGKEVDLETLEYIHLHKTGALLKASVRTGAMIAGANEELLNALTTYAEGIGLAFQIIDDILDLTSSSEKLGKTAGKDLLADKTTYPKLLGMEESKKKAFDLVDQAKKAIEPWGLNAKYLISLADFITNRDR,<ps2>,MTEVINNIPDFEKYLTDTKKVVEEALDFSLGPENPEILRESMRYSLLAGGKRIRPILCLASCSLAGGEPSLAVPTAVAIEMIHTMSLIHDDLPAMDNDGFRRGRPTNHKVYGDAIAILAGDALLTRAFEMVSLRSPGVDSNRLLNVVGELSLVAGAPGLVGGQVVDLECEGKEVDLETLEYIHLHKTGALLKASVRTGAMIAGANEELLNALTTYAEGIGLAFQIIDDILDLTSSSEKLGKTAGKDLLADKTTYPKLLGMEESKKKAFDLVDQAKKAIEPWGLNAKYLISLADFITNRDR,<
+<ps1>,VNFWGFINLKFLLDVLFALGFGLLLFSRVKEQRTLWLLRGYLLLVSFAWFIQRYAYLPLTSKLIDAVVLACSLSLAILWQGELRRLMELLGTGRLAVLLGNPPKEFRATSTTVNQLVDAAGKLSQNRKGALIVVDLGSDLRPEDFLYSGIKIEAKLSTDLLINLFATDTPLHDGAVLVKGNKIISAGVILPLSRQGISRYGTRHLAALGITERFDRCICIVVSEETGTLSLANQGKLERPITSSRLQELLIKLVGNQNTSGTPKSSSNKTNSYQKTNTNDTITVEKKLDKQNTIQD,<ps2>,VNFWGFINLKFLLDVLFALGFGLLLFSRVKEQRTLWLLRGYLLLVSFAWFIQRYAYLPLTSKLIDAVVLACSLSLAILWQGELRRLMELLGTGRLAVLLGNPPKEFRATSTTVNQLVDAAGKLSQNRKGALIVVDLGSDLRPEDFLYSGIKIEAKLSTDLLINLFATDTPLHDGAVLVKGNKIISAGVILPLSRQGISRYGTRHLAALGITERFDRCICIVVSEETGTLSLANQGKLERPITSSRLQELLIKLVGNQNTSGTPKSSSNKTNSYQKTNTNDTITVEKKLDKQNTIQD,<
+<ps1>,MENPTKNKIQNLIDLNPVMVFMKGTKLMPQCGFSNNVVQILNSLGVTFNTFDVLSDFEIREGIKEYSEWPTIPQVYLKGEFLGGSDILIEMYNAGTLKEKIEIALAS,<ps2>,VNSNSSNQVGKNIRRTGFLIVLSYLLIVLIMKVLEANNFFGYSLSSFSNDIFAPPSLKHLCGTDRLGRDVCLRTLQGSSIAIEVVFLAIFFALILGLPLGLLSGYFGGILDKCLSLVMDTIFSIPVILLAVVVAFVLGKGIINASIALCIVYSPQYFRLIRNQTMLIKSETYVEAARVSGADVKTIIFKYILPNVITPLPILLTLNAADAVLVLGSLGFLGLGVPANVPEWGSDLNLALAAIPTGIWWTALFPGLAMFFLVLGLSFIGEELENIFEN,<
+<ps1>,MENPTKNKIQNLIDLNPVMVFMKGTKLMPQCGFSNNVVQILNSLGVTFNTFDVLSDFEIREGIKEYSEWPTIPQVYLKGEFLGGSDILIEMYNAGTLKEKIEIALAS,<ps2>,MVMNVSIVIPTYNRKPILEKCLKALEKQNLNENISNYEVIVVDDGSTDGTTYWIKDNYEVLPHVVLYEQEHGGPALGRNLGVMKSKYEIIIFIDSDLIVLDDFIACHVNKLLFSWSKNTKKCFTYGSVINTSNFSNPESERYKLTDFSFAYFATGNVAISKELLLSVGLFDNSFSLYGWEDLELGERLKKLGTKLIKCPEAVGFHWHPPFDCGQIESLVSQEKERARMALIFYKKHSNLRVRFMIQLTPIHILLWQIICLGGLISIKRLLPLLRFLIDSGRNRIALEIVRIPLNLIYVKELRRLI,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MKVNKKYKGLVTKKFNEFYLVELDKYETSVANKKFLCKIKKSVNFRNQFVFVGDEVIVYQIDLQSKRATIESLVKRNNLLERPSVANISNIYVICSVEEPKLNLSQVNKFLISSEQLGVEVSLVLTKCDLITEEKRLLLIEKFHQWGYQAITLNLNNPENLRTLLIELKKKKCSIFMGPSGVGKTTLLNMIIPNLDNKTAPVSSKIKRGKNTTRNVELFSLSSKSYIVDTPGFNIQTLEIDIRELSNLYPEIYKQVVNEGIHCKFRNCLHVNDEGCKLNKNFERYTFYKEMVESSKSHYCLIQED,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MAGFGLPNFGQLTEAFKKAKEIQQNAQKLQDELESMEIEGKSDDEMIKVWISGNQLPLRVEVNENISTANKEEIEKNILEAIKKAHESSTTTMKERMNDLTGGLNLNLPGLDNNDS,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MASQISYRGNKNPIKKKLSFFEGGHQLEKLEFALAVAQTKGDEQKSLVLMKKIIELGGNVEEPGT,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MITLYQFRHSAFCLKTRMALHAKKLQYRVEEVTPGLGQFEIFKISGQKQVPIIVDDNDQIISDSTIICEYINKKNDNNPLFPKDPLLFAQCKLIEDWADTTMASTCRKALIKSAIENPQLRTALLPDEIPSSVKGLVDKLPFKNLSKISNVVFSTKDNLELQKILEALSKALINKKYLIGDNLSIADIAISAQLSLLKFPKSSGPILSGEGCQEYINNPYLENIFIWRNNIEEYLFSANSQ,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,VLIIYRSNSLTAKEASIFCNKTLKERNIKSKRIESDFDNNQLENYFYNLAALPDLVIVLGGDGTVLKSANALVNYDIPILSFNIGGNLGFLTQEKDFLFDQSFIKILEKEEFIIDFRNRLHCDVYSNEKNRERKILKSYDALNDFYFKSVEEDISPTNQIQIEIDNEKVNEYKGDGLIISSSTGSTAYSMAAGGPIVHPSINAFVINPICPMSLASRPIIIPDTSKVVIRVVQKNKREIKLWKDGSKCMTIKENDYCEINKVTKPCKMIKFNKSISYYITLIKKLDWKGDLSLKNNQNN,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MSKKRKRISRRRLAGQRVMAHVPIYHIETGKHKPVTAARRFIAENALSAPSVFNVRRNEHTTDRFFWGQKGLFSAQYAEENHFLFPSLKVVVEGIGEEKIFEGLELTADDWEEIEEYEYAFV,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MSKIKENKEQFWLEKFDCFSVTGKDSKRFLNGITTGNIVDLNNKVLKSCWLSPNGILKSLLEINCSEKELKVIVLVGNTSEIRKYFNDIIFPSDDVSLSDSFSINRLQQVDDMNSWRITQPIFLKNEDKKYDFYKNNPNSMNTNDLQLWKINQAIPSLNSEINGKNNPLELGLTDLIDFNKGCYLGQETMSKIKNVSSLKQEIRVWTAKDKDVNLESVNKILFNNQNKEKSVGYITSIYVLESRIIKGLAMIKRKYLDKGNPFFSDNFGQISLEKSVGSTFL,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,VENSINISILIPLIPMGMALLILSLLVSFNRTINRLTKPVSALAVFSLLSSALISAFLYFKKIEGEIFLSDYLKLFGSTNLILHLNSLTEKIVIFFAVIIAIVIGVLFYKLPRRKGYVSLIIGISLISSSIMFAVFFLDFSFLI,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MKRKEDSKNNNYDSMSFTDHLEELRQRLLNSIYSILICIFFSFLIIKPLISFLEIPASDIHLLQLAPGEFLFVAIKVAGYSGIIVSIPYIFYQLILFISPGLTKKEKNLILPAVFGSGLLFFLGLIFSWWILVPAAINFFINFGADIVEPTWSIERYFDFVLLLMSSTAIAFQLPVLQFILGSLGIITTEKMLSNWKIVVISSAILSAVITPSTDPLTMSLLSISIIFLFFVGAGLTYISESLKSKTLSSSH,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MTINEKIISDKELKISDWELDFYSRPIIETNGKKRWELIISSSKSFKTEKIFLWNKVCPANEVNSIWLTKALNEALNDAEIEGWAKPLKIRFWRASMKSIIKKSIENIGIEALVSRRTYELFDRIEFLEREIYPLEQGYVRGVLAPTFTSNILNDPKPLPEAVRGDALTISEISIEELKLAKNWPIEFGDIFPIQSSIKNDNLVPGLRLFSKDRSLALAAWFSSLEPVKLLIKQNQLILEASEDDKWLVTDLQEKDAKVLNDKFTQSKKDSYGYQFISIQATPFIEKFAGFWILKDVELIS,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MESIFNNSFATLVAYVGIVSIYLLVIPLILFYWMNNRWNVMGKFERLIVYGLVFLFFPGLILFSPFLNLRLRGDSKG,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MTNKKRILSGVQPTGDLHIGNWLGAINNWVELQEKHETFLCVVDLHAITTEYDTKQLSKNTLSTAALYIACGINPKICSIFVQSQISAHSELCWILNCMTPINWMERMIQFKEKSIQQGNNVSIGLFDYPILMAADILLYDADYVPVGEDQKQHLELAKDIAQQRINAKFGKEENILKIPQPIIMKKGSKIMSLNDGSKKMSKSDINEGSRINLLDTPEIITKKIKRAKSDSYMGMEFNNPERPESRNLLMIYSLLSGKEVSELENDLSQTGWGTFKKIFTEQIIESLKPIQERYQVLINDPHELNKILIQGKEKAEVVANKTLSRVKSELGFFEIEK,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,LALIIPSNYHKISDVEKNHISWIEPDLAERQDIRPLRIGILNIMPLGKQYEFNLLHPLGLSPLQIEPVWIKLKTHSYKTWDLNHLNNLYTTWEEANDPEPLDGVIITGAPVEHLAFEEVKYWDEFVNITNEARNSCASTLGLCWAGFALAYLAGVNKTVFDKKLFGVFPLKSLAPGHPLMGTQDDEFICPQSRFAGLPDLEMEEAQKEGKLNLLAYGKDVGYTIFETKDQKQLMHLGHPEYTVHRIISEINRDKEKGDVPPPENFDINSSNTSWRSHRNLLFQQWLWFCYQQVSLS,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MHSKINYFLGIFLSIVILIFNEPSFAINNPNLLPEEKTPVIDLAKTLSPNQKKSLEENLNNLEKESGWKIKYLSQFESVPGIAIKDYWDLDETSLLVIADPRGGNLLNFNVGEAYFAFMPRLFWVELQTRFGNQYYVKDHGEDGAVLDAINSVKICLDRGGCQVVPGLPKEQYIWTLCTSILGGLVAGFAAAPRKEGQIISIGFLALLSPLWGMLFGIFGLAPIISRTSEVLPLFKNGLAFAAAAIAGYLLSQTVFSRYEKPKKS,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,LTNYTHYTTVVVHLYYLLMTLGGANVWSNFSYGSRVDSPNGWILNPQGSFLILFENCKKSARNNINVYTHLLFTNHLGEPAGLKNTRLHDLDSAFETWNELIAGGWTEVTNQFQESA,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,LKEDSSYLIKYTSSGLYCELADTWIDPIKPVKRALITHAHMDHFTFGCDEYISTYETAVIIKERIGKEINIKTYDYEKEFKINGIKISFHPSGHILGSSQIKFSLAEEIWLITGDFKRQKDETCKEYEIVKTDYLISESTFGLPIFKWDEPQKTASDITKWVNSSQEKTSILFCYSLGKAQRLLNEISKTNFINNIYTHSSIYRMNNCYKKLGIDIIETTKLEQTKNNSDLKGSLIILPPALNKSSSLKNFKDIQTGFASGWMSIRALRKRSGYDKGFSISDHADWIAILKTIKESKAKNVFFHHGESEALNKYLKEKNSINVLEFEFKK,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,MNFKNHHQKKRFGQHWLVNNLILEKIKEVAELEEKDFILEIGPGRGALTSKLLDSKISRLHAIELDEDLIDLLNNKFRNDKNFSLQQGDILSTNLDSINKKITKVIANIPYNITGPILDIFVGRLGIISKNNYNKIIFLMQKDVVDRILAKDGNTNAGAMSVRMQLISNIRRICDVPPSSFDPPPKVFSTLVVFEPLRPEMRLDIKLEKYLDKLLRISFNSRRKMIRNTLNSILSAEEIEKLSESSQICFNSRPQDISINKWIKLAEACIKITNKNQ,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,LSRLLISFIFFAIVFLSPLSTFASHTSDPTVSLLQSRISKNFSKKFCNAIQNGLSKDEAMTSAIVKTENIVSFSYNPQKKWIEKEDLANQISIKVINDCGWSFGLIGKEGIDYFNSYFLEIYDKTTPDKKLSS,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,VNKKKLYLANPYGFSKQTKNLLPEFIKIFQNLNVEVYEPFERTKHLITNKNNWAYDLAKANFNDLKSCDCIFAIVNGNPPDEGVMVELGISIALNKEIFLFRDDFRNCSDSDQYPLNLMLFVGLSKESWSKNYFESIEDILNPKKSFLNWAKRI,<
+<ps1>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<ps2>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<
+<ps1>,MANSQVTTESGGRQNMFPSETRPYIDESVSYDSYPKNAEKVNGRWAMIGFVALLGAYVTTGQIIPGIF,<ps2>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<
+<ps1>,MLNLIKKNLNIKSGIALIVLATIFVFLSNSFKKNKSKDISNFVVSVEKGILSESINTSGEVKATRTSNIGPRKQGILEEIKVEEGDLVEKGQILATLDDEDFIYKLEELELNLKKQKSEYLRREFLFKEGAVSKEDYESYKNKYNTSEAKFSDAKAEKDFYSIRAPYPGKITAKYAEIGSYVTPSSNLSSNSKAKNFIFELSEGLEIIAKVPESDIGRIKTGQEASVRIEAYPSNKYRAIVKKIAERAVKDNNVTSFEVTLKFKEISEEIKIGMTADLEFKVKSSEEKILVPTVSIVTEKGEKGVLKVDKNNTPKFEKIEIGISSGNKTSIIEGLRPGEQIFIDIPPWANKRK,<ps2>,VRIFMKLFKSLLVAPATIGLLAPFSTFAGEANLNDISKYSNLEHLDLANAFVNDEPKNNSLLAGGEGLVDSGSSDGGFSQTTTASFSVDAVLGAIDGNASATTGQGEETGFDFQFNIGLSTSFTGEDSLDIAIDNGSATASPIGAKMGFDTGTSLVVDGVTYSFPVGGATMVVGDATDVSATYTGACTYSAFTDTTLDDCGTGNSIGAGGKGVAASLGYAFDSGFSIAGGISSPTTEIVGDDADLYGLNVAYSTDSYGVAVGYAIDDGGTGAETTTWGLNGFYTFDLASLSVGYETSETGGTDSSGYFVGLSFSEVGPGSVNVGAATTGLFADSVTEYLIYEASYSYPVNDAMTITPGIFIEETAGDDLTGVAVKTSFSF,<

MED4_100_RRS.csv

@@ -0,0 +1,101 @@
+<ps1>,LSKRNPIILIHGLWNTADIFSSITSKLDEIGIEYFSPTLKHEYGMTSIVELTNLLNYLILEKYGYEKELDILGFSMGGIIGRYWIKKLNGYKRTRRFITIGSPHNGTLSSQLIPKYPFKGISEMKINSPLLRELSRSDYLLSGIDCISFFTYWDLMVFPGWRACLNSGEKISLKIYKHKNLVRNPDAVDKIIEKLLN,<ps2>,VRNSPFLPNRPLKVAVLGSSGAVGSELLKILEERDFPISELVLLSSQRSEGKIVKWKGEEIITKKASKEEFLNVDLVLASAGGSISKQWLSTVKDQNAVLIDNSSAFRLENDVPLVVPEVNACEALKHNGVIANPNCTTILLTLVLAPLNKISPIKRVIVSTYQSVSGAGQLAMEELQFLTKKYLQGDPKESEVLPYSLAFNLFLHNSPMLSNNYCEEEMKMTNETRKILNITDLKLSSTCVRVPVLRAHSESVNVEFDDVIKPSYAINQLKKAKGLEIIEDYEKNRFPMPNDVMGRDNIAVGRIRTDISNSNGLELWLCGDQIRKGAALNAVQIAELLIAKK,<
+<ps1>,LTNYTHYTTVVVHLYYLLMTLGGANVWSNFSYGSRVDSPNGWILNPQGSFLILFENCKKSARNNINVYTHLLFTNHLGEPAGLKNTRLHDLDSAFETWNELIAGGWTEVTNQFQESA,<ps2>,MLRKLIHPILILPFCLYINSQEALLSKANNSIEEILHENENQIFLNYSDIDNITLKNNRELKALESLVNSTMFTLSSKIAKRYPSLDLQASGLPKYTSGKNYNSSSSTTKTSQFSANPSLNIKLDLIDPLRGSEIKIARNNYAIAKNNYEIKKKDLIKEAKSRYHKLQKSYQDIKNKTLSLDLSITSLKDAQSKFDAGIGTKFEVLEAEAQLSRDMQSLNEKKIQNQINKIELKEILNINGDFEINQKQKLIGFWNHKLNKNITEGLANSLSLKNINLKKSIKENQAKNYLNVYKPNVYISNNFTSSFSKGDSLSVKIDPEKSGSSYTNTVSLNFSWNIFDGGQNKNLYKSSKADVKSEDYSYKNIENVLKTNISKAYLNLKLNEEKILSSLKEISSTEESLRLARLRYDIGISTLKDVLVRQKELSNANSKKIDSIYNYNLNLDELVRLTFLEISNICNEENNLIKNEIQSICNI,<
+<ps1>,MNQFFSRRSFILIPIMSILKFILQPKKVLAAFAASDDDWNLSKEDWKNKLSPESYYILREEGTERAFSSQLNNEKRKGIFYCAGCNQPLFTSDTKFDSGTGWPSFWDPIQGSVETKVDFKLIVPRTEYHCSRCGGHQGHVFNDGPLPTGKRYCNNGLALKFIAE,<ps2>,MTNTKVSNNNPDKESIINKSITKAKDNEIIKNKTIQNKKVNSVSKEPNKSVDDISNELFSELISKKISLVQEIKDLETKKNELEKDIESNFKGQSDNIAKRVKGFQEYLTGSLQNLSQNVEKLELVSQPIVVKPSPLDEKKEASNKNELLTVPALSETFKPDEQLIRSCFSNFIEQPDFYSEPWKLRRSLDSSDIEVMDDWFFNMGGRGSLESRGSRQKNALLSAGFIAILGELYGDQFQTLILASQPERLGEWRRVLQDSLGLTRDDFGPNSGIVLFERPEGVIERADRLEANEELPFIIVDAAETSVEIPILQFPLWLAFAGSNDEIYDDLELN,<
+<ps1>,MVKEDPVRLELSITPSYGKNPVIVGIVESLDLVARRDREGRMPRDLQGTWDWTVRHGKVSTGGWNPMLKEALQTMFETGLPSIIYEELTGDEYKPVDGIRHVR,<ps2>,MSEYRDSSSNNFLSLISGAFIGAAGLAWWLISEADKRKEEKKQKAMMYSSRIQDGSEAIDTNENIKDVEGDKLEQKVEELNSAIADVRRQLEELGQ,<
+<ps1>,MSLTQSKEVNSLSRRYSTYIERRITRTVMVGDIAIGSDYPVRVQSMINEDTMDVDNSYLAIKRLHEVGCEIVRLTVPSLAHAKAVGDIKEKLIKNNIDTPLVADVHHNGMKIAMEVAKHVDKVRINPGLFVFEKSDPTRTEYTDTEFETIKKTILKRFTPLVEVLKSENKALRIGVNHGSLSERMLFTYGDTPLGMTESAMEFVKICDELDFHNIIISMKASRAPVMLAAYRMIADRLDAEGYNYPLHLGVTEAGDGDYGRIKSTAGIGTLLAEGLGDTIRVSLTEAPEKEIPVCYSILQSLGLRKTMVEYISCPSCGRTLFNLEEVVDKVRKATSHLTGLDIAIMGCIVNGPGEMADADYGYVGKGKGTIALYRRKEEIKRVPEDEGVDALIRLIKDDGKWIDP,<ps2>,MSKVELISLTPEAEKTMAYIARVSNPSNQANDKFAGLLRYCIKHEHWSVFEQSCMTLKIETNRGIAAQILRHRSFTFQEFSQRYAETSLLGNEIPIPNLRRQDQKNRQNSIDDIPDELKIKFSEKISKHFQEANKLYEEMLNEGIAKECARFIMPLATPTRIYMTGSCRSWIHYIQLRSKEGTQKEHMEIAEDCKKVFIKYFPSVSEALNWE,<
+<ps1>,MKKLFLLSLLISLISPIKTSAGFPEGEKGYDLKKIEDSFKLPCDEIGNDECIARAFGVGACTWVFGIKNGKDSKEALRIADGVLIALLKGNNLDINSIFEKDGSIKETIQKESVYRINFCKDATKLAIPKLIKKLPEGVELDDERIENLADVFPLQYLTMFEQMRKRN,<ps2>,MKAAILVNQKKKLIVDELDLPTSLKVGQVLVKLEYSGICGTQIGEIDGVKGEDKFLPHLLGHEGSGIVEKVGPGVKTVREGDSVVLHWRQGNGIQSEPPKYNWNGKTVNAGWVTTFNTKAIISENRCTKIPANISKEDAALFGCAVTTGFGVIENNAKLKMGESIVVFGAGGIGLNIIQAARLTSAWPIIAVDLFDNRLDLAKKLGATHSVNSSNKSYLDEIENILKDRELDVFIDNTGNTSIIEMGYNLISDQGRLILVGVPKTGENINIFSLPLHFGKKITGSFGGECNPAKDIPRFIKMMQNGLWDLKGLITESYDLENINEAIFSMRTGKTSGRVIIKL,<
+<ps1>,MNNVVQNKSKIFYQLQKLRRLAQPFFLPIDQCNGFQFIWLLISLLFCVGGIVLVALTGIISFFESIQPIFLDKYFGGVVNTVNTIWSGWWGLLFSGLFLIGSGSFFSLRRQLKNRRWVHWLFLAVIVLMLLAVNGINAGIGFIARDLTNALVEKQQDGFYRILGIYACCFAVALPIRVSQIFFTYKLGIIWRDWLSKSLVKDYMTNKAYYQLNPNDEEQTDVDNPDQRITDDTRAFTGQSLSFTLGVFDALLTFSLNILILWSISTTLTFSLFGYAAFATAILLIAGKNLVKIDFDQLRYEADFRYGLVHIRDNAESIAFYSGEKPEKSETERRLGEVVRNFNLLIIWRVIIDVMRRSINYAGNFFPYLIMAIPYFRGDIDYGRFIQASFAFGMVEGSLFFIVNQIEELAKFTAGIGRLEGFQSKVESISQTKPIDNQNIISDYSSILINNADLFPPGSDKAIIKNLNLSIETNQSLLVVGPSGCGKTSLLRMISGLWEPNQGSIKKPKTGDLLFIPQKPYMLLGSLREQLCYPTEVDKFSDDHLISVLNEVNLNSIVDRYPNLDVKQDWPRILSLGEQQRLAFARLLLNSPRFAVLDEATSALDIKTEKRLYNLLRDRELSLISVGHRPSLKDFHENILELNGQGGWKLFTTDKYNFKN,<ps2>,MNRWVLLEHKILSSKFIDIHYDFLVEDQLDCLTWKFHEIPSLNKGVIKIVKQPNHRLVWLSRVEYQLSKNRGLVKRIDHGIFSNIPHNQDSQKLKIILNGKLLNGLFIIDGNFCQLTKNN,<
+<ps1>,MKYLILGSGSFAGQLIFSEYLERNYDVYGFNRSRVKDHYQWPWIKKYKNDLGNRWFEYNLTNDVEEMISHINRLKPNFIIDFMGQGMVAPSWLKPEVWYTTNIAIKSRLMNALIDSSFLQKYIRIGTPEVFGSNENFLKEDECFNPSTPYAVSHAAIDFNLRCLYKQYNFPYLIGRFANFYGVGQQLYRIIPRLFLSCRSERNFILDGKGESRRSFIFSKDIVSAIDSMIKFDGIGQEFNFSSNEEISIMSLVNKICNLTNVDKSRILKFGPERPGKDRYYRLDIKKSKNVLNWEPEVSLDEGLNIINIWISENIENLSNKSWTYEYKD,<ps2>,LSLIFINLLTSIPEYISKAVETNSTIAYLTICLAMFLENIIPPIPSEIIMPLGGFFVYQQKLNFYILVFWGVFGTILGSMPWYYLGKLVNEKRLSNFLDKRGKYIGITSNDLIKSRRWFDKYGVSLVFWGRLVPGIRTLISVPAGMELMPLRKFLIWTSLGSLIWVTLLTYAGFVFGENYPIIETYLNQIKFIVKPILILIFVYFLIKFFIRLYKKKIT,<
+<ps1>,MGENLPLLLSAALGKKVNRPPVWMMRQAGRYMKIYRDLRERYPSFRERSENPELSYEISMQPFLAFKPDGVILFSDILTPLPGMGINFEIIESKGPIIEDPIRNIRQVEKLKELIPNESLSFVGEVLSSLKKDVKNEATVLGFVGAPWTLAAYVVEGKSSKNYSLIKSMAFKEPDLLHKLLDHFAKSIGEYLKYQIKSGAQVVQIFDSWAGQLSPQDYDIFAGPYQKKVVDIVKEEFPDTPIILYISGSAGVLERMAKTGVDIISLDWTVDIEEACKRIPTGIGIQGNVDPGILFGNKDSIKERIDNTFNKVKERKYILNLGHGILPGTPEENAKTFFEHGKKLTY,<ps2>,MRGSIKRSNESYQDSYSPNGIIGEKDACGVGFIANIDGKESNWILKQSLKGLNCMEHRGGCGGDSDSGDGAGILCSIPWEFLDRELNLNTESYEKRGLGMIFMPNNELKVKESKLICDEEAKELNFKQSFWRNVPIKNETLGILAKANAPFINQWIVCLEKDDSRDIEMLLFQLRKRIEKRIRDNTKNAIGECEFYFASLSSKTVVYKGMVRSEVLSEFYEDLKKEDFKVSFSVYHRRFSTNTLPKWPLAQPMRFLGHNGEINTLLGNINWAKASEIHIDDYWGELSRDIKPIVDKNKSDSSNLDATLEINIRSGKPITDSLLKLVPEAFRDQPELESREDIKAFYEYSATLQEAWDGPALLVFADGNYVGATLDRNGLRPARYSITNDGFVIMGSETGVVDIEENRVIEKGRLGPGQMLAVDLSQNKILRNWEVKAEAAKRKNYKKLIQKRTIKLKNNEWSNTCNLKDFELLQQQTAFGFSSEDNDLILDSMASLSKEPTYCMGDDIPLAVLSSKPHILYDYFKQRFAQVTNPPIDPLREKLVMSLEMHLGERCSPFEFNGIKPFIHLKSPIINEKELISLKESEIKSKTISSLFDIEERIKGFEAKLDDICKVSEKAIKEGCSLIIISDKGVSSKQSFIPPLLAVGAIHHYLLKKEIRLKASLIIETGQCWSTHHLACLIGYGVSAVCPWLTLESGRHWLQHPKTQKLIATKKINPLSIDDVQENIKKALEDGLRKILSKIGISLLSSYHGAQIFEAVGLGSDLIKIAFDGTTSRIAGITLKELANESLLIHTKAFPEIDLKKLEFLGFVQFRNNGEYHSNNPEMSKVLHSALKQGPGYDHFETYKTLIRNRPVTSLRDLLSINSTRKSIPIDEVESVESICKRFCTGGMSLGALSREAHEVLAVAMNRIGGKSNSGEGGEDPARFNVLNDIDENTQSAILPSIKGLENGDTACSAIKQIASGRFGVTPEYLRSGKQLEIKMAQGAKPGEGGQLPGPKVDSYIAKLRNSKPGVALISPPPHHDIYSIEDLAQLIHDLHQVHPRAKVSVKLVSEIGIGTIAAGVSKANADVIQISGHDGGTGASPLSSIKHAGLPWELGVAEVHKSLMENNLRGRVLLRTDGGLKTGWDVVIAAILGAEEFGFGSVAMIAEGCIMARVCHTNKCPVGVATQKEELRKRFKGLPENVVNFFLYIAEEIRQIMSSIGVSNMEELIGNQEFLTARDIKLPKTANIDLSSLIKKGTQYKDRSWLKHSKTAHTNGYVLEDQFLSDNEFMNSIKNHGKVIKEIEIKNTDRSVCAKISGEIAGLYGNNGFNGELNLNFKGYAGQSFGAFLLKGMHIQLIGEANDYVCKGMNGGVLTIVPPQVDEKSSEQVILGNTCLYGATGGKLFALGKSGERFAVRNSGATAVTEGSGDHCCEYMTGGKIVILGSTGRNIGAGMTGGIAYILDENNDLENKVNKEIVSIHKITSLKQEEILLGILGEYLEKTKSLKASKIINNWSNFKGIFKIVVPPSEEETLGI,<
+<ps1>,MIEKKGDNIRSENFYPDSNYYLDQDNTPEETTLPEDQIFNTKKFEWPNSYWFIAERTNGRLAMIGFMAVIINYTLFGWIAYPIL,<ps2>,VHKNKILVPLSNNSYEVIIKQGLINNIGEELIRIGINSNRKILIVSNKEISTLFGRKLLNNLKKNNFNAEIFNIKAGESHKNFASLSEIFNAAFEVGLDRNSLLIALGGGIVGDVTGFAAATWLRGIEYIQIPTTLLSMVDSSVGGKTAVNHPKGKNLIGAFYQPKAVFIDPETLITLPTREFKAGMAEVIKYGVIKDKSLFEYLENEKNRDKILNLENESLIKIINKSIKTKACIVSEDEKENGIRAILNYGHSFGHVIENLCGYGEYLHGEAISIGMKIAGDIATEKNLWSKEHSLRQDHLIESYGLPIQTPKIKKNDVMKILMGDKKVRNGKMRFILPIELGEVDIFNDINESQFLKYFN,<
+<ps1>,MLKNDLWINQKASKGMINPFQSNLVRHLDPNNKKNAVLSYGCSSYGYDLRLSSKEFLIFKHVPGTVMNPKKFNPDNLEKTILHEDKDGEFFILPAHSYGLGVALEKMKVPENITVICIGKSTYARLGIIVNTTPAEAGWEGHLTLEFSNSSGADCRIYANEGICQLLFFEGDPCSTTYEDRKGKYQNQPEKVTLAKI,<ps2>,MKKTKVICIGEALIDRIKNKSNQEFTDFLGGAPANVACALRKLQIDSVFIGRIGSDEFGKKFINQFKELEVNINFLQLDDCLPTRIVKVNRDNSGDRYFSGFDTSLNTFFADEAFDKNEIKKDLKSLENLFSKTKYLVCGTIILSSSISADTINFLLSLANKFDVKIIIDLNWREVFWDFATSSSETNKKERVDLIRNLLNKAHILKLAKEEAILFFENKNPLEISERLLNRPDVIITDGANPICWLINGVQGTTEVSKSLKIIDTTGAGDAFLAGLISQLLSFDYPSNESEIQNCVKFASICGLLTCLGEGAIEQQPDYSKVNKFFGSQIL,<
+<ps1>,MVSVPFSNNGSNKNFKKDFNNENAGLVPPQNIQAEEAVLGGILLDPDAIGRIADLIKPEAFYINAHQEIYKTALMLHTQGKPTDLTSMSAWLADNGSLEKIGGNSKLVELVENVSSTASIEQVANLISDKFIRRQLIRSGNEVVQLGFDQTQETNEVLDKAEQKIFEISQEKPTKGLTQAAEILTSTFNEIESRSLGTSVAGIPVNFYDLDAMTQGFQRSDLIIVAGRPSMGKTSMVLNLAKNVAQSQDLPVCVFSLEMSKEQLTYRLLSMEVGIESGRLRTGRLQQEEWPLLGEGINSLGQLPIFIDDKPNLSVLEMRSLCRRLIAEQKKELGLIVIDYLQLMEGTTPDNRVQELSRITRGLKSMARELKVPVVALSQLSRGVESRTNKRPMLSDLRESGSIEQDADLVLMIYRDEYYNPETEDRGITEIIVTKHRNGPVGTVKLLFEPQFTRFRNLAN,<ps2>,VELMGQFFSNVARYPKYLISIIAGGLVALLEPLFKNRSNPLTLVGLISSVISAFITFYFVLKAMTNPINL,<
+<ps1>,MSFSKLVEIKNNFKFDANNSCKNLYKGACVKIKNSQKTFQVVGINPQSKVCWIREWPFALEVNKTFSLELNQITLQTYCSDTFNEK,<ps2>,MAENFSFDVVSDFDRQELVNALDQVKREISQRYDLKGTDTSLDLEKDNIFITTNSELTLNSVIDIIRQKAIKRKLSIKIFDFNSIEVVSGNKVKQTITLKKGLNQEIAKKISKNIRDEIKKINVSINGETLRVMSKSKNDLQLAIKLLENLEETYKIPLQTNNYR,<
+<ps1>,MNKRHSLQRKTTLKWNSNGDLSEIDMLRILDRISAYELNQCELTCDLDE,<ps2>,MASQDYLIAIALIEQNNIRAMPLGGKEIKEKLEEEGNLIKLGEEVILNLLLRVFQRSDEGALKRVSEDKGLLLVHMHPKRMQKELPFIKSEWIRDGDTTQFLKYLGNLSKEIWTASLIKYKGLELVSIAKNEDI,<
+<ps1>,MVEKFKTLFFVKSSLISLYLALTCPIPFISSEKLKIFSIITFFFGLLLIINITNDYVDTCDKKISYKTSFISKIFGKKNWEIFWKDIKLIKSLPTSQGSNIHYFISNKNESFLVPQRVENFERFVSIIEEKTKLNIDKLSYISPLWTYKLLTYMSILMIIGELIAFII,<ps2>,MSSNKICLNCGSSDLVSDRSLGGRMVCFKCGSSSFKNNSFSRIQNKKIIYLLIVLVILLIVVL,<
+<ps1>,LTNSIKGRNSKEVTIQLKRAETQKNILIKNIYKEYETYFDIVRKSMLISAKKGIAGIYSDFSISDKALHSKELNIFLNKNISLLINSKLPFITIEQLKLGDISYPTKQLVNASVLKELVKRKEYQTVHIDHENEKTANESIEFHCDNNLNTYEYYESLSEDEISSVNLDESCYLNSFSKEISIENIEEGKRLVNAFLELIEETSDNKLIDYEKINDQAPDVFISSDNLNTFEFIDKSFSNFLLNLSYNINLELFKIELIKKIITEETFKCLSNNNSIIKHPYPFVIRYDLYPDNLYPRKNKSSDVYLFNITNVELELYNLDLSICRNNINDLKNRFKLLNKKQRYWKNKELASNSSK,<ps2>,MTDILVLILFVLSGAASGWLGVDLLPIDILKQVSNVEGFRIVLAIIGFFIGLAAGFVFLQLRKTFLDQIRTMPTDLLISRAVGLILGLLVANLLLAPILLIPFPREVFFAKPLAAILSNFFFGALGYKLADTHGRTLLRLFNPTNTDAYLVNEGIIPAASPKILDTSVIIDGRINGLLSCGLLEGQLIVAQSVIDELQTLADSSSNEKRGKGRRGLKLLKELRELYGRRLVINPTKYEGNGVDEKLLRITEDMAGTLITADYNLSQIAEVKELKVMNLSDLVIALRPEVQPGESLNIKIVREGKEKLQGIGYLDDGTMVVIDDAKKFVGERLDIVITGALQSPTGRMVFGKLINNPESNKSFKSPATQG,<
+<ps1>,VHLDKSSSEIINKFKLSPHPEGGWFREIIRSKNHVTRNDGQKRNNITSIYYLLCKSERSKWHRVNSSDEIWIYLQGAPLNLYFLDDNKELRNIRLDLNNPIEMIPSGYWQAASSTGEFTLTSCCVGPGFDFNDFQMLRNIDPSLRPAKAIKELI,<ps2>,MFFWYRVLSLWPLRRRIINLERFRGLHDDYSKSSTSLNAIRELNDTCNVNLLCTPYVAYIPNSDYWRPNQARDLYKLHLKKSSKKLKIKFIDGSTVIDTKDIKNYAPLGPHLSKLGYQKFAELLSSHLSKKK,<
+<ps1>,MSKVEIYTWRFCPFCIRAKSLLEKKNITFTEHKIDGDDNARELMMERANGKRTVPQIFIDDKSIGGCDELYELEKEDKLDLLLN,<ps2>,LTIYLGFLYLFFGIIFLLMPLIYIELGRPRDFIKGGLNLVIGMLLIYKQNIFNTLNYLIFSVITTLLTFYIVEIFSIRWNQLTNQEKNNLLTLEELKKNLSIFLKAISLARQDFLNSNNIFKFGRKNENLNKKKWVRNDENDNIVNSNKNNLLTLEMPKKATNKSTKDTINEGK,<
+<ps1>,MKLSLLSAVLFLFTEISFAQEKLNYTVTSDSQIQSIKGNFEAIGNVIIKSTNNNFEASSNKLTYDKDAKTLKLVGNVFVKNLESEGLSIQKSYGDELTIFTDSGLFKFNSENKNRVKTKLKF,<ps2>,MKNLKSNKRKIHRKVAAISSIPLLITLISGTIYSFLQPLGVDAFWLIKWHTGNFGIINLQPFYSIFLGIASIISVISGIRLLQKNS,<
+<ps1>,MVCVSNNKSYLKSQHLKIIGQKTLRGKVKISGAKNSALVLLAASLLTDEKIILDNVPLLTDIEKMGNILKNLGVKLHNKDHQLIIDSKNISIQELPYELVNGLRASFFCIGALLTRFGEASIPLPGGCNIGERPINEHINGLRALGAEIIIDRDVVKAKLVKKKTKLFGANIRLNCPSVGATETLIMAASLAEGRTVIENAAREPEIQDLCQMLNKMGAKIYDSGKEKIIIDGVHKLHGCTHKVIPDRIEAGTFLIAAAATSSSITVSPVIPNHLEAVLNKLEESGSKIIIKGNSISIKGNNIKAVDIKTAPFPGFPTDLQAPFMALMTIAKGRSKITETIFENRMNHVDLLNQMGSSITLKNNIAHINGVKKLRGMTLVGSDLRSSAALIIAALTSKSVSYVYGLEHLDRGYENFEQKLSKLGIEIKRQITKQTINKSKNRSSNSKLKEVSEIRAA,<ps2>,LELVDNINPGLVNNLLKMKSKIKQTFKLILFIFLTNTHFLQAHNLFNGGCKNHCKESVKPLIMNKELNNSSYKNQIEDDDSCLIKSLCRG,<
+<ps1>,LIFIMIQFASFAIGGFVPSAAIAGVLVLIGLGAFFYLGLKGPTDY,<ps2>,MYSLEISLRYSPFPLSIQKKEYEDIKRIYDEIKDSMNSDNQNSPLIELSCEKVQDKLITVLAKEVISVQIYEKSAVAGGSKRPGFSLDI,<
+<ps1>,MSGIKTKNNTQKLSFRLAPYLFIAVAIFTAFGTNGGTWV,<ps2>,MRNSWIQPRIGQKNITQMNFAKNGHITEEMNYVAKKENLPPSLIMEEVARGRLIIPANVNHVNLEPMAIGIASKCKVNANIGASPNASDINEEVEKLKLAVKYGADTVMDLSTGGVNLDEVRQAIIKESSVPIGTVPVYQALESAHGSIERLTEDDFLHIIEKHCQQGVDYQTIHAGLLIEHLPKVKGRITGIVSRGGGILAQWMLHHFKQNPLYTRFDDICEIFKKYDCTFSLGDSLRPGCLHDASDDAQLAELKTLGELTRRAWTHNVQVMVEGPGHVPMDQIEFNVRKQMEECSEAPFYVLGPLVTDISPGYDHISSAIGAAMAGWYGTAMLCYVTPKEHLGLPNAEDVREGLIAYKIAAHAADIARHRAGARDRDDELSHARYNFDWNKQFELSLDPERAKQYHDETLPEEIFKKAEFCSMCGPNHCPMNSKISDETLDELNNKLTKCDTSV,<
+<ps1>,MKSPVLKNPNQDWHPNIWPPFTQIINSKPQLEVTHGKNALIYTKNPKQELIDGISSWWVTLHGHSNDYIADAIYHQAKTLEQVIFADFLHPQAQILSERLSGLTKLERLFFSDNGSTAVEVALKIAYQSWQNQGETRNQIIAFDGAYHGDTFGAMALGERNIFNENFDNLMFPVKRAPWPSTWINDEEVERKENNAIQILTKLLKKPTVAVILEPLVQGAGGMNMVRPEFIRRVSEVVKNNNSLLIADEVLTGFGRCGSLFAFQKANIIPDLISISKGLTGGFLPMGITLAKETIFQSFISDSPKKTFWHGHSFTANPLGCAAANASLDLLEKDPIKYLSFEEKHLSHLKKIKKLPFVKNIRVTGTIAAFDIEIGKNEGYLNNVGKRIKALSIKKGLFIRPLGNVIYLLPPLCITDRQLEKSYRIIFEILSDL,<ps2>,MKSLLNTHTKFEIMHIVLRNFKFLIFLFLLSLNLSGYSNAHMRGTFLSEEDARNRSLELGCEGIHKNQDKWMPCKNEKELHKFLNKKGSSRGNNLASSLAWIFILSSSFGILWLSIVKIKRK,<
+<ps1>,MNNAKNLKIKQIDKKNISFKELSLIKNIIFWVDIIPGDQTQKNAIFARPFHDKNAIPQKLTGDNFYIKSNFHGYGGKSYQCIEVNDHIYLIWVDQLSKAMWLKIFKVQEKVLKNDNQYLLCDVEPRQLTESIKTNFDTSFVISKNNLLFGLCEIKHRDYLFSLNLKKTKQDIRIIKKFDNFAGNLSSNISADLFSWIEWNAGSMPWERNELFFAMIDNDGEIQNIKNFSNKFVNEEKNVSFFQPYWMSDTTLVCSEDSTGWWNLLFLDLTDIKNIILKKRIIKPLTEYGSPQWVSGISFFSGNIKNLFCVAKKDNSWVLEHYQNCECIKELKLPFCSIGDLDVCDQKLVIRGCSFGCFEELFECDFGEKSHTKLLNEISLESINEYSRPESFWFKGFNNQPTHSFIYKPLFERFIKSPLIVKAHSGPTACFDGSLNSEVQHWTSKGFTVAEVNYGGSSGFGREYRERLNYKWGILDSYDCKALVLDLIRLNLVDRTKVAILGNSAGGLTAINALCEGDLFKVAICKYPVLDLNDMHQHTHRFEKGYLNSLIGRYSKFHNEYKLRSPIYKINHLKKPVLLFHGKKDLVISCKKTLQIKEKLLKNNKNSEVIIFENEGHGFKNTNNKKQVLIKTQEFLEKTLNI,<ps2>,LSRILLLSNGHGEDLSGSLLAKYFVKKGDLVDALPIVGDGENYKKENIRIIGKTKKFRTGGIGYNSFSGRIFEIFGGQIIYFFKKLYLSYKLKNKYDFYLVIGDIVPVFFAWFAKKDFFTYLVAYSSHYEGKLKLPWPCKFFLISKYAKKIYARDFLTADDLSQQLRKKVSFLGNPFMDKFSFFENKPKIVPFNIGLFPGSRFPELLDNLKLILEVLETMSKLQYFENIAFKFAIVKALSMEEIRQILNQRKWIYIEKKGKNDGLEFTFGFITINLNWNLFEEILFESNFVISMAGTASEQAIGLAKPVIQIEGNGPQFTKSFAEAQRRLLGRYVFCSTNYINKKDQINQTINLILKVIYLIKLDKKFLVSCLDNANLRIGESNSCLKIINDIKGFHEK,<
+<ps1>,MMIPISLQKNQNRHIIKSVRKFIDRFFKIKKNQNLNMTEQRKIEKFGVGNLYPDIHPPEFSFFKEKCIDVALGYDDGFTFTPKFGNFKETEDIFDYLKQYLEDKELEKLDIRFDTLKTCIYQINPETLELGELLECEGSDVEYFEWNKKTKSIDEVDSNSLSDEEEEYFH,<ps2>,MIKIFALTFSEIGIGKLEIFVIGIVSLLFPILFIIASRNLDAKGVFDWMMEKPNDWIGKK,<
+<ps1>,VFDISKENFFKNLIKFPKKNIFMILLFLGFGEWFLSDLINFAGGSIGFFILCFGGYFYLKSEKPKFNEPKDLDGWIKLCNEDLDFFEEIELHNNLEKQNINRKKALELILNREKKEEIYCIGQKNFDSNATLFKNYFKEDKFKLNFMERLPKYNSSEIVPEVILNSDAILYFLKLPLSANDFLWLEKLPKNMPIWLVASFTKGLSFNNEIEEVKAQISGEYANRIIKFDKTKNSFANIPFSLRKFFISSNNNIENTKKRLLKRLHTNWQSEIEGIRRMQLNDLQRRNQIIVATSVFFSPIPSIDVLSMTVLNSLMIKEIKSIWGCNWSPEILDKVSKQIIKTAIAQGVIEWSGQTLIGLTKLHGPNWLVTGAFQAISAAYLTRVVSSSLADFMALTKGVSEPDLEFIKENSDKIVERAFENEKINWKSLIPELNIPLTRLT,<ps2>,MIKNTKKSQKNKILTLEDVSISYGTFEAVRNVFCNFKSGDITSLIGPSGCGKSTVLRALNRMNDLIPNCSLRGTVLFDGTNIYDKRVDPVEVRRRIGMVFQQPNPFPKSIYENIAFGARINGFVGDMDELVESSLRKAAVWSECKDKLNDSGYSLSGGQQQRLCIARTIAIEPEIILMDEPCSALDPISTLKIEETMHELKKNYTIIIVTHNMQQALRVSDMTAFFNAVEYEEGDGGKVGYLAEFDSTKKIFSSPKEKTTQEYISGKFG,<
+<ps1>,MWIRFHEKNGSERLNFTAFYEALLEAKGVNLGDTGVAGIGKGGRKLSYIATVQGNGNLLIGKAYTALLDLKAGDEFEIKLGRKQIRLLPSE,<ps2>,MTISDKIRVYELSRDLKLENKDILDAAQKLSISVKSHSSSISLEDAKKIKNLINKNSSKKILSVSKSAIKAKNENPKNNDNKNNKNFSNPSHPEKLSKEGLNKKPLLIKPTNKVVNSLVSSNIKNPNPPTIVSNLKSQALSKNQNKTNTSVITTPNLKDKKNPSALQDKKPLKNSSGSPAKTTARPPIQLIEKPKNLANSNRNINANKINNSVNQKAQSLNRADNNKLSRADNNNFPKKNLNSPNVKSTPELVGAPIRREDPKINTNRPNSNSRQPSSNTQISANRPGGQNRQGVPNREGGPYRQGSPNRPGTPYRQGAPNRPGGQNRQGVPNREGGGPYRQGSPNRPGTPNRPGTPYRQGAPNRPGGQNRQGVPNREGGGPYRQGSPNRPGTPYRQGASGIRKPVAPNELMQLQKTNASNKEKPNISNVNKQKIEGANQKTKAPNSRLNTSPSPTAKKPARSFASNTKKPGRTDWDDSAKLEALRNKNPQKQRQKVHIIGENDDSLTSETSGYSGEKVSILSASLARPKKEKSEEIKSQKPSKQFKKKKKETTRQRQKRRAMELRAAKDAKQVRPEMIIIPEDNLTVQELADKLSLESSEIIKSLFFKGITATVTQSLDLATIETVAEEFGVPVLQDDVQEAAKKTVDMIETDDIESLIKRPPVITVMGHVDHGKTSLLDSIRESRVASGEAGGITQHIGAYQVEFEHESKKKKLTFLDTPGHEAFTAMRARGTKVTDVAVLVVAADDGCRPQTLEAISHARAAKVPIVVAINKIDKEGASPDRVKQELSEKDLIAEDWGGDVVMVPVSAIKKQNIDKLLEMILLVSEVEDLQANPERLAKGTVIEAHLDKAKGPVATLLVQNGTLKAGDVLAAGSVLGKIRAMVDEHGNRIKEAGPSCPVEALGFSEVPTAGDEFEVYRDEKSARAIVGDRATDARATKLAQQMASRRVSLSSLSTQANDGELKELNLILKADVQGSVEAILGSLEQLPKNEVQVRVLLSAPGEITETDIDLAAASGSVIIGFNTSLASGAKRAADANDVDIREYEVIYKLLEDIQSAMEGLLEPDLVEESLGQAEVRATFAVGKGAIAGCYIQSGKLQRNCSLRVLRSDKVIFEGNLDSLKRSKDDVKEVNTGFECGVGCDKFSTWSEGDIISAFKFVTKKRTLNK,<
+<ps1>,MNKTITPSIETIERNWFLVDAKDKTLGRLSTEIAAVLRGKNKPTFTPHLDTGDFVIVVNAEKVEVTGKKASQKLYRRHSGRPGGMKVEKFESLQERIPERIIEQAVKGMLPHNSLGRQQFKKLKVYKGSDHPHAAQNPVLLNS,<ps2>,MKIILLVFFFIMFSFIFLKFYKYKKAFKKDKSIKFNKSNLYNWMNLTKKERFDLSKKESNSYLKKRKTLLEEIRKEYKIISKND,<
+<ps1>,MTELNQKNSGKNIKWHNLTIDRNKLEKMRGHKGMVIWFTGLSGSGKSTLANAVNEVLHLDGFSTYVLDGDNIRHGLCKDLGFSDEDREENIRRIGEVANLFMNAGIITITAFVSPFISDRDKVRKIIGSKDFIEVHCAADIEVCESRDTKGLYKKARLGEIKEFTGISSPYEAPVNPEIVVDTGSLGLNDSVEKVINHLREQNLLERS,<ps2>,MESDNLFSNTYRIESNAPLADKLRPKNLDDFFGQESILGHDSLLRNAILNDKVGNIIFSGPPGVGKTTLIEIISSNTRSSLIKLNAVLSSIKELRTEIANAKERLRSSNRKTILFIDEVHRFTSVQQDALLPSIENGTITFIGATTENPFFAVNKALISRARIFSLLPLNKNDLKKIIDKVIKYYSCLKDSKVVEIKEEAINHLIKFSGGDARNLINALELGISITKENKENLVVIDLAIAEDSIQKKNIVYDKNGQNHFDVISAFIKSIRGSDPDATLYWLANMVEAGEDPNFIFRRLLISACEDIGLADPNAIVVVQSCCDAFDRVGFPEGLFFLSQASLYLAISPKSNSTKSIFKALEAIKATNVSLVPNHLKNNASNYLNPHNYQGKWLQQEYLPTDLQGIKFWKPKDSGWEKNKYEDLPKKQKS,<
+<ps1>,MSASKREEVSSHLRYIRLELREMHQMLIRDDLLPDLSEAKEVHAQLDALYELLSDKRKKKVKNEFENF,<ps2>,MEAFHPPKEVKETIDDSGLPKEEGISEKWLREKIDSLIPLIQEKWPNIAQQTLETAKGSIDDLVGVIASHTGSSASGIKNQLFQIIDSIQENNWEIADKIEPIESQLEELLDELNSTLRPKIETPIRKKPILSIAIAAGIGLFIGSLINSRNK,<
+<ps1>,LNYWIQNLAPDGSPDEIGVIQLAWLGDSVWELHQRLRHIHIPLKSRDLHLSVVNEVKAQAQSKALDEIEHLLNSFEINLIRRARNKTKRFPKSSDPAIYSRATGFEALVGWLFLKDPKRLSKFFEYLECK,<ps2>,VTQIDSKKKFDRLRLCKLLETIYKEHTTEELNLICNQLLQILDNFSEKSRYEEISEDKKWDESFAVLITYADGVYKKGETTLVTLRELLSKNFGSLSKVVHILPFLKSTSDGGFAVSSHTSLEEKFGSWEDLKSISNKHYLMADLVLNHVSSSHPWVQQFIKCQEPGLSNVFSPSQDLDWKNVIRPRSSSLFSQINTDDGQKQVWTTFGPDQIDLNWLNPKMTIEFLNLIITYLSNGIKWLRLDAVGFIWKEPGTTCLHLSKAHSIVKILRILLNDLLKDGVLITETNVPQKENLSYLLPEDEADMAYNFPLPPLLLEAIISSRADILNAWICDWPELPKTTTLFNFTASHDGVGLRALEGLMNEQRIKDLLINCEKRGGLVSHRRLSNGEDKPYELNISWWSAMEDPGRDSNRYQYERFLLTQLLVMSLKGVPAFYLPALLASENDIKSFSMTGQRRDLNREKFKSEKLAAVFNNPESNANKNLKYLRHAMDVRAKLPQFHPQSHMECLSKNRADIVALKRGIGSKAVFTIHNMTENKINYRFIDYEFNKLIKNDLNMQDYLTSNKYNSNNIELDPFQVIWLGF,<
+<ps1>,MTSSKPKKSSRVRKTTKNSKKNHNTMMPLLPKTPPSFKNKVVDKKALKNLVSWAYKTHGTAVTAAMADNLKDLGFKYATQAAVSISVNDLKVPEAKQDLIGQAEAQITATEECYRLGEITEVERHTKVIDTWTETNERLVDAVKNNFNQNDPLNSVWMMANSGARGNMSQVRQLVGMRGLMANPQGEIIDLPIRTNFREGLTVTEYVISSYGARKGLVDTALRTADSGYLTRRLVDVAQDVIVREEDCGTERSIVINSEDGKFGSRLIGRLSAEDILDSEGNLIVPKNTAIDPSLSKTLETSLISKVNIRSPLTCEANRSVCRKCYGWALAHNHLVDLGEAVGIIAAQSIGEPGTQLTMRTFHTGGVSTAESGVVRSKIKGKVEFGSKAKIRGYRTPHGVEAKQAEVDFLLKIIPTGSITNKAQKIEVTSGSLLFVEDGQDIDSDITVAQITSGAVKKSVEKATKDVICDLAGEVRYDKVIQPKEVTDRQGNITLKAQRLGRLWVLAGDVYNLPPNAKPVVSTETKVEQGTVLAEASQSSEFGGEVRLRESVGDSREVQIVTTSMLLSNFKLIEESTHSGELFHLESNDGTIYRLNTSPGSKISSGEVIADLADERFRTKTGGLVKYAPGLSVKKARSSKNGFEVSQGGTLLWIPQETHEINKDISLLMTEDMEWIEAGTEVVKDIFSQTSGIVTVTQKNDILREITVRNGSFHECEDEEILSRFTEEGKLVNPGEKIIDGVDNDEILFVQKLETSKGKGLLLRTVEEYTIPNEAELPELSHVKQEKGPSLALKAIQRLSYKDGELIKSVEGVELLKTNLSIESFDATPQMTIDVETIQDKSDKSINRLNLVILESILVRRDTISDSSHGSTHTELQINNNQLVKAGDVIATTQILCKERGVLQLPDSVEGEPIRRLIVERNEDKIKINIKDKAVVKTGDRVVDGDLISKGVKSTSCGEIEEVSSEYVILRIGRPYMVSPDSVLHVKDGDLVLRGDGLALLVFERQKTGDIVQGLPRIEELLEARRPRDSSILCKKSGVVQIKEGTDEESVSLSVIERDDSISEYQLLMGQNIMVSDGQQVTGGELLTDGPINPHDLLDCLFTDLKDQKPLMEAAQESISKLQRKMVNEVQNVYKSQGVAISDKHIEVIVRQMTSKVRIEDAGDTTLLPGELIELRQVEDTNQAMSITGGAPAEFTPVLLGITKASLNTDSFISAASFQETTRVLTEAAIEGKSDWLRGLKENVIIGRLIPAGTGFSGFVEELASEAGPHPDILAEESGGYRRTQNLRPDYTVDMPQTPIVSSTAILDDPSDEDLETTRNRHGIDPTSSNFAAFARPNAENQFSEDQLPDPAALEGLQEEGLLSDG,<ps2>,MQNPAEKKSSILKDFKNLFIWIIIALIIRWQVIEPRWIPSGSMLPTLQIQDKILVEKLTPKITSKSNLSKLKNKIIVFNVPEQLIDAGYESDIALIKRVIGVPGDKVEVKEGNLYLNDIAQNNYISDKNINYSTGPYYVPEKSLWVMGDNRNNSMDSHIWGFLPYEKVIGKAIFRYWPLNNIGPIRFPSLNNLG,<
+<ps1>,MEDWQEWEYFDYHGELRSKRTKICITCTHFRYSTTDQCVTILTCPFHQKLIPQGDHLVKGCTYWRKDSRIFAPEAA,<ps2>,VRFHIQQEIDIPASTQLYNQICFAIAARYYPPGHRLPSTRQLAMQTGLHRNTISKVYRQLETDGVVEAIAGSGIYVRDNLKKSFNSKNNLNTTPALETKKAVDKLIKLGCTLQETRNLLTNEIDWRIKCGSRIIVSTPREDIGASMLIAEDLSPNINVPVEVIPMEELEKVLCNSNNGTIVTSRYFLQPLEKLAKQYRVRAIAVDLSDFQKELKIIKELKPGSCVGIVSISPGLLRAAEIIIHSMRGSDIVIMTTISDNSNRLLALLKASNHIVCDGPSLSVIENTLLKNRSQLMRVPQIICAKNYLSIKTINHLKTEIGVIN,<
+<ps1>,MKVIVIDDDPTGSQTVNNCLLLLKWDYSTLIKGFQSKSNLFFILANTRSLSENDAKLRLVEICNALKKVISKESYKEEFIFVSRGDSTLRGHNFLEPKIMNDCLGPFDATFHIPAFIEGKRKTIDGEHFVDNVPVSQTIFAKDKIFGYKTSNVKQLLFQKCKSQIKFNDIQNLKISELKVLESKEKNIVFNKIRNLKENSHVIVDIENYSQLQKFSLSIKKLSKQKKFLFRTAASFISSISAVKDNPKEPFFYSLIRRKNREKKFLPGFLVIGSYIELTTMQLKEFLEISDCIPIELDVFEFLKISKLKSNQDQLEVFKNKLLAQIRSILKQENTPVLFTSRKEVSLARNDEQVNFNNSLAHFISELVSDLKNEIGYLVSKGGITSNVILSNGFKANYVYLQGQIITGVSLVTFKLENDENLPIVTFPGNIGNQDSLVKVWRILENKNNSSN,<ps2>,MRILHTMLRVGDLDKSIDFYVNILGMNLIRRKDYPHGEFTLAFVGYGSEKDNAVIELTHNWSKKSEDYELGNKYGHIAIGVKDIYDICQGLEDNGCNVTTKPKTMKNSTTVLAFVEDPDGYKIELIERD,<
+<ps1>,MANNFYQWWKNHRRVVTFGGFLILLGLYVSPVIKEAKYKNMCIKLSEKGALNKLNGDNIGETLLKDTGLSIEELAKIEGYRNCF,<ps2>,MNDLNIEFPLDDFEELISQIGWSSLDEWFIFWNLKKEMLSINNFWDDNVKDDWIWGLALPLLSQAYKLNKKSPDRKIIGISALPGTGKTTLGKWLESISLKLKFKLSVISIDDFYLPSEEMEFAIKNNPWNVSRGFPGSHSIDLMKEKLLKWKTDGQLNVPVFDKSLRKGLGDRAHWREESPDLLIIEGWFLGVKPLSIDLDNSEKFSPPLSVFESSYRNKIQNNLDQYLDIWNMIDQIWHLKPLKFEYLNEWKSNQEKSMHFKSGSSLKGDNLSNFLRMLNVSIPHKSFDDINSDVLLMINQERKLVRVGLNQQISK,<
+<ps1>,MKLNQFLKWHNIVSSGGEAKILINSGQIKVNGEIEKKRGRKLVKGDKVMFLKSELIFE,<ps2>,MKPQLTLQTPLELPHQEISNYLNQLWISEDEESVGANTFTLMVWQPAWLEQCLVKSGLISGPITGTLSPEIIKVAKKLIIDKGLSHTTSIHSEELLTLLKENLLNKDYEDLRGQFFESSISTLNPRRLITLAPTLNKESEIKTFVSAYCPLSDNTITQPICGDLVVIRGDSNSINNKGLKIIDDLSIKDLPIWLWWNGSLDESQEIFNFFTDQGIRLIIDSANGSPKRCLKILYQSIKSNKAINDLNWVRLKSWRESLAMIFDPPSRRPILEHISDIDIDIAEGNFLQALLLISWISDKLEWVFSKINKHGDLIKIEFKRKNGENILTCINPVPLGNPSIHSGQVIGLRLISKISEVRKNNTCVILGCESVECMRLEAGGMADMQLIEQVVPNSFSSSESDVSKLLGSSRGNTSPLFENAIKVAVQIFNGFNK,<
+<ps1>,MKDKQEKIRMFLPFSWVICAVISFAYINSHLINT,<ps2>,MEFNIQDKVKLKNPLSYLKTSDNMPMLRPPDLVAIDEVGEIIAIKSPDTVEIKFRRGSFLIDTDKIEKTQI,<
+<ps1>,MKYLILGSGSFAGQLIFSEYLERNYDVYGFNRSRVKDHYQWPWIKKYKNDLGNRWFEYNLTNDVEEMISHINRLKPNFIIDFMGQGMVAPSWLKPEVWYTTNIAIKSRLMNALIDSSFLQKYIRIGTPEVFGSNENFLKEDECFNPSTPYAVSHAAIDFNLRCLYKQYNFPYLIGRFANFYGVGQQLYRIIPRLFLSCRSERNFILDGKGESRRSFIFSKDIVSAIDSMIKFDGIGQEFNFSSNEEISIMSLVNKICNLTNVDKSRILKFGPERPGKDRYYRLDIKKSKNVLNWEPEVSLDEGLNIINIWISENIENLSNKSWTYEYKD,<ps2>,VTQRHFFVTTSSSSAAEKTLKTKIWKRVFIVCMILLISGSFFYFNHEENNTYILKTLELNGSVKEGDTLFKMNCVGCHGITARGLVGPDLQSITMRLNDAEIIKQVIEGVTPPMPSFEIDPQNMSNLLTYLHSL,<
+<ps1>,VENDEIKYKKDIPIEWLKMPSSAKEAEKLNIKKYFIGDKRFMRELEDRDEYNAA,<ps2>,VILKTIKISNKLCLIGIIVFCLFQNHSVSASREPLIRVLISKNRNLRIRSDKSIPLIIKGQKFSNKKIKGLTVKKENNTTSLFFDKNKQKIYDLKNKVKLVVKSSDGRGIWVGQKRYSGILNLLVLESEILVINILGIEKYLSSVVGSEMPAKWPLEALKAQAIASRTYALKQKGNQIYDIDSTQKNQVYNGLESRTYKTIRAVRSTRSLVLTYKNKLINALFHSSSGGMTENSQDVWKNEYPYLSSVRDFDRNNPKLQWKKKFSSGELQKLFPEIGGIKKIEILNITNTGRVKNVQIFGKYGSDQISGVDIRKRMNLKSTFMRFKFIEDKKYISDNDNSNNPIEKTLIVFGRGSGHGVGMSQWGARYMASKGQKADRILKHFYKGVGIKPFSKNYL,<
+<ps1>,MSIETTVLDFKLSNTFEEYQAHMNAPEQQAMFKEMGVKTFYIGKSLEDPKRATVMFQGPVNTCYDIFVNPETKPIVEASGHIYEGTIINRWIS,<ps2>,MMFNKQKKLILNLKILKLLFFSPLLISIPFYLGNSDAKAGLEFQWDQDSGYRRLKWFQKENKKRFRNTIFFFLRPSDRQANLLKITLNIPKTFDSTLKDKVSFCKVKIGGFEGRTKCIEDIPADVDINEDNSSLDIYPYSPIPSNKDSYAIVFKKISNPKKSGLKQFHSYGQYAQKNTSSRYLGSWTIVID,<
+<ps1>,MNFITNSRQFHKSLAPWVFLPLFISALTGTFYRICKDLLGYSRDEVHWLMSLHEGEWLGDNGELIYVILNSLGLIWMLITGFQMFSKKISFPKKVTKGESKG,<ps2>,MASFTVGIVVFPGSNCDRDVSWALEGCLDIKTKFLWHESSDLNDVDSIVLPGGFSYGDYLRCGAIARFSPLINSLHDFIKSGRRVLGICNGFQILTESGFLPGALVANKNLNFICDDVDLNVITSKGGWFQKLNENQNIKLPIAHGEGCYHCDQDTLKRLVDNDLIALKYKTNPNGSTSDIAGITNEKGNVLGLMPHPERACDESIGGIDGLYTLRSLITQ,<
+<ps1>,MNNSQRSVTHSQNGDYRTIEQTMEKLSGGTRRLAAQLTTSATFNSLWNVLTDYDRLNLYIPNLLSSRKIYKNNNNVHLKQVGAQDFLGMKFSAEVTIDLFEEKELGLLKFSLIKGDFRRFEGSWKIKKIKDTSKNSLIYDLTVQGCQWMPIGMIEKRLKKDLSENLIAVDKQAKASIK,<ps2>,VILNPELQEKGEIKDLMKSRGSFRAFPLAAITGHSLLKLSLLLAAVDPSLGGVIIAGGRGTGKSILARGLHTLLPPIEVLDNESILEKLTMSNSNTSLRPIGRNLDPDKAEEWDISTNKLLEEVIGSDYLNQIEEIPKKVREAPFIQVPIGITEDRLVGSIDVAASLSSGEQVFQPGVLAEAHRGVLYVDDINLLDDGIVNLILEATGREQNNIERDGLSLSHPCRSLLIATYNPEEGALRDHVLDRFAIVLSADQSIDNNQRVEITKSVLSHAENNIKFSEKWSEESDNLSTQLILARQWLKDVKITKEQITYLVNEALRGGVEGHRSELFAVKVAKANAALRGDENVNSDDLKVAVRLVILPRATQIPPQDDDIQPPPPQDQSPPPPQSNNEDSEPESNEKEDNQEEEQDNSDGEEDSTPDIPEEFILDPESCMVDPDLLLFSSAKSKAGNSGSRSVILSQSRGRYVRPLIPRGKVKRIAVDATLRAAAPYQKSRRLKNPNKTIIIEENDFRAKLLQKQAGALVIFLVDASGSMALNRMQSAKGAVIRLLTEAYENRDEVALIPFRGNQAEVLLPPTRSITAAKRRLETMPCGGGSPLAHGLTQSAKVAKNALSTGDIGQVIVVGITDGRGNVPLGTSLGQAEVNENENVDLKQEVLDIAAKYPMLGIKLLIIDTERKFIASGFGKELAEAAQGKYVQLPKATDKTIAAMALNAINEF,<
+<ps1>,MSKDFKSGKVKRLPINNLNLPNFVNNSLRNNTKVNTVEGTNVIRVPFGKRFPKKQRPDKNQNIATLILPINTFINPTPPPHVA,<ps2>,MPSLSDGDFYYYRNFYIDQPPQMAQVFYESLHVISFSLKIIFYFLERLSDVN,<
+<ps1>,MRHQLRVPLLSKPADQRKALLRALTTQLIREGRITTTKARAKALRNEAERMISLAKEGTLSARRRALGYIYDKKLVHSLFEKAQERYGERNGGYTRIVRTVARKGDNAQMAIIELV,<ps2>,MKDIFLVLDSYQYQMESNYQETSSLTNLFTENKFIGWLGLFIVFFSIFAIIIFQFLEWESNDKNKE,<
+<ps1>,MNERNKSLWKQAIKWPLYSVAILPVFISGAYTLNSFKNVKIYNLIAFTIAAILILIWENLTNDLFDSETGIDEFKFHSIVNLVRSKTIVSITAYTSLLIGLVVIAIISISTSINVMLLVGACCFLGYLYQGPPFRLGYQGLGEPLCWLAFGPFAYAAALIALNPSDIYMISIPWKESLLLGSGSSLATTLVLFCSHFHQIKEDKEHGKNSPLVLLGAKKGAKIIPWIVFIIYVFQLFLIINGFIPILCVLFLISFPQSLKLINLLKYSYNKPEAIKNCKFIAIKFQTLNGIGLIAGFIINYLIYK,<ps2>,MKIMDNFDDDLSLKQKEFVEPIDKATNKDLFEKKDEFKEATPKVLHLNSLITKNIYLFTKDPNYKLFAWLMVQLFIFSLFVLVATLMKNNLVPYINSL,<
+<ps1>,LLLMKRLLLAAVLFLLSEISFAKEKLNYTITSDSQVQNGKGNFEAISNVVIKSINNNF,<ps2>,MDEDSRKVTEEVWLICPNSTEVRRFTKNKNNKDKFFEYMFVDSGIIIGVLGAKPPLMKTRKEIKIEAARKEYQQLIISGWQVTIPKW,<
+<ps1>,LDQFEVKVFIRLRPSVLDPAGEAIKSASSKLGVAGIKSLRIGKLIEVKIESNEEDIKEKIELLCDRLFANTVIEDYEYSINKL,<ps2>,MNLKQITQKDQLDLKKIYFDSIISIDQKIYTSEQKRAWASQAWDNKYFNLTLKEGKGWLINEREKIIAFASRYPNNRISLLYCRGDSQRKGYGTKLLKKIEKEAIKEGLPCLTTEASLISYKLFLKNSWKIIRKEKIIIKNITFERYKMIKNF,<
+<ps1>,MEQGLNNPGPLTIFLVFTAGLLTSLGPCSLSLLPITIAYVGGTKNNKFKLISFSGGVIFSLITLGALSGFLGKIYGQLPSYYASLVALIAIIMGLNLLGILKFQLPNGPDLQFMEDKVPSIITPFVVGGAFGLASSPCITPVLATLLAWVSQAKNPTISIIFLFFFGLGQVTPLILAGATTENLKQFLELRKYSQVIPTLSGVFLVSLGILNLISNWI,<ps2>,MKENITELWFSWFYKNWEKNAPGNLIDKGLSPSQIAERFVNENHKEFLEIANEFDEDNYQALNEFMKLSESELHILKYFLKLIKLKNS,<
+<ps1>,MGTANLHDSTNKPLYGERIIEESNIICFENPNKKRIYEISIELPEFTCKCPFSGYPDFAKLNIYYQPNMKVYELKSLKLYINKFRDLKISHEEVVNRIMDDLLKAAVPHWIHLNADFNPRGNVSMKLDIYSGQKRN,<ps2>,VRIIFWGTPEYSVKSLEVLKKSDHDIVAVITQPDKKRSRGNKLISSPVKEYATKENIPVFTPETIKENIQFISILNDLSCDLFIVIAYGKILPKAILDIPKYKSWNAHASLLPRWRGAAPIQWSILEGDKITGVGIMRMEEGLDTGDVLVEKQIKIENNDNLKTLTKKLSDLSSELFLRAISDIEQNKNRDINLLLKKQTDFKRELKYARMINKLDYIINWENSATDIYRKINALYPRANTTYKRKNLKIIKIKILTTHEIHNKNYKILSNVFKPGLIIGLIKNVGIIITTKTDPILLLEAKLEGKKVSSQNQLIQQLNPVIGENFSD,<
+<ps1>,MAQLETRTEPMVVNFGPHHPSMHGVLRLVVTLDGENVIDCEPVIGYLHRGMEKIAENRTNVMYVPYVSRMDYAAGMFYEAIVVNAPERLANIVVPKRASYIRVLMLELNRIANHLLWLGPFLADVGAQTPFFYIFREREMIYDLWEAATGQRLINNNFFRIGGVACDLPYGWLEKCIDFCDWFAPKIDEYEKLITNNPIFKKRIEGLGTIERDQAINWSLSGPMLRASGVSWDLRKVDSYECYDDFEWEIASEKEGDCYARYRVRVQEMRQSLKIIRQACEMIPGGPTENLEAKRMATEDKKSEIFGMDYQYVAKKVAPTFKIPNGELYTRLESGKGEIGVFIQGNNEVTPWRFKIRAADLNNLQILPHILKGAKIADIMAILGSIDVIMGSVDR,<ps2>,MVRKISFIGVGPGDPDLLTIKALKKIESADVIFWADSLIPEKIINFSLKGSEKIKTSTLTLEKITSIMIERFNEGKTVIRLHDGDPCLYGAVKEQLEILRQENIETEVIPGVSAFQVAAAYHQAELTIPDITQTIILTRAGGRTGMPEKESLKDLAKHKSSLCLYLSARHIKSSQKTLLEFYPPETKVIVGYRVSWDDGWTSLIELKDMEKFTLEKELIRTTIYIVSPAINTIANRSNLYNPSYKHLFRGK,<
+<ps1>,MLRPPFSQESISIDKWDVIVIGAGAAGLMTCLELPENLNVLLLNRNTSKRSSSRWAQGGIASVVRPEDSFALHVEDTLKAGDDLCDLSAVEMLVKDAPGCVDRLQNLGMIFDQSSDQLSTTLEAAHSCRRVLHVKDRTGRALVEVLEDHIENKENILHCRGVRVTELLIEKEVCKGVQVLDGSNLYWITSKAVVLATGGGGHLFTNTTNPAQSAGEGIALSWKAGVAIEDLEFIQFHPTALKFYGSPCFLISEALRGEGAVLVDKNGESPVKHLENGDLATRDQVSRAIMNNMQENDVDHVGLDLRFIDPEKIVERFPMIISRCQDYGVNPLNEVIPVAPAAHYWMGGVHTDLNASSTMKGLYAVGEVASTGVHGANRLASNSLMECLVFARKMSCIELNAPYNLRRLDRYTTEIFMDNPKEDFILGVSDKIDSLRKLCWSNLGVSRNKKNMNKLLKTLQDEIDQLQKNPLLECLNKIEIDQKLKLSEPNRRGLNLLLDLHNRQITTLLLLKACLFREESRGGHYRDDFPIKETTWKCHTRQQLNQEIIKRFIKN,<ps2>,MRTILISGANSGIGLNIAHKELKAGNRISIGLRDLESVKGSVIDPNNWTNEKILLNKYDALDKFSAKKWVENTVSKFGGFDTLINCSGVLSKVPFLYKDGDEEEILNTFNINFLAIWHLCRISWKHLSQSNNGRIIVLVSMSGKRSKGDLAAYSSSKFALMSLCQTMKNKGWEENIRVTAICPSWVNTKMAEKISSIEKSKMTQPGDIAEICSTILKLPMQSVPFEIALNCNYEI,<
+<ps1>,MSRKSELLKGEETKNFSEFSQLADFSLMNSLNADPHSTKDGNDHRARSVNSGHYVPVTPTPIPEPIYVSHSKTLFKELGLSSDLTKDKNFCRFFSGDIEVAEYPMRPFGWATGYALSIYGTEYTQQCPFGTGNGYGDGRAISVFEGLFNGKRMEMQLKGGGPTPYCRGADGRAVLRSSVREFLAQELMHALGIPTSRSLTLYVSGTEIVRRPWYTEGSRYFEPDIMVDNHAAITTRVAPSFLRVGQLELFARRVRSNSHDDAFNELKIIVQHLIDRNYRDEIDPSYSFNEKVIRLANLYRGRLISLVTNWMRVGYCQGNFNSDNCAAGGFTLDYGPFGFCELFDPRFQPWTGGGEHFSFFNQPFAAEINFKMFCSSLLPLLLENKEDIEKLEKIKNDFSKFMSKEMQLMWAKKLGLEKYDETLTNELFNLMVNSKVDFSIFFRKLSHIPDNISFLKDSFYLPSSEELDKEWFIWLKKWQDCINKQGDLKEISKSMKQVNPKFTWREWMIVPAYQEAEEGNYNKIKELQTIFKNPYEEESLEIEQKYNRLRPREFFNKGGVSHYSCSS,<ps2>,MNYIQIKDLSKSYSDIKALKNLSMEINAGTLFGILGPNGAGKSTLIKILATLVEPDGGEVFVNNINLIKNPRKIRELIGYVAQDIALDKILTGRELLDFQSDLYHMNKKEKYERIKLLINQLEMNDWIDRKCGTYSGGMKRRIDLAAGLLHLPKVLILDEPTVGLDIESRNIIWQLLKDLKNDGMTIILSSHYLDEIDKLADSLVIIDDGKVIAQGTPAQLKNKLGGDRITLKVREFSNHEESKKISEILSSINGISQIIINKAQGYAINFVVDKEKDLLTKLKVELAFSKFEIFSLAQSQPSLDDVYLQATGKTLLDAEISMTGKRDLKKESKQSMR,<
+<ps1>,MFLISAEKFSLWKKKQLSKGGDNHSLNLLLESLGGLSNIELNLLKINLEKNLNFKVNLDLIESFWDKHLNTSIPIQYLSGISFWRNLKLEVSNRVLIPRPETELIIDIISGIFKNKEEKITFVDLGTGSGAISIALALENPNWNGIATDIDKNAIKIASRNFATYSNQSNLKFYNGNWWDPLKNFKGEIDFAVSNPPYIPQDTYEVLPIEVKNFEPKLALLGGQEGLDHINQIVQNAPLYLKNKGWLLIENHFDQGEKVKKLFLENRFTSVKVLKDFSGIGRFTIGRYK,<ps2>,LFDKENLKYFLIWPMSVLLAIFFKYYGFLKPDFLLINNYLVLLLVCGPALVVTIILVFNKI,<
+<ps1>,MKLQTQFTVPKKEFRDLDYVNKVKVLEETLKKECMDYPTKEDCLVCCN,<ps2>,MSKLKGPDGRIPDRLPDGRPAVAWERRWTEGTLPLWLVATAGGIAVIFVLGIFFYGSYQGVGAG,<
+<ps1>,MNNKRIFHDPIHKEIIIDSDKPEELMIMQLIDTLAFQRLRRIKQLGAASLLFHGAESSRFTHSIGVFCVARKIYRKLVEINPDFSQNKFILFGAALLHDLGHGPLSHTSEVIFAHDHELWSKNLVKNYSPISSILKNFGTELPNQIGDLFKTKNLFSRPLKTLISSEIDCDRLDYLLRDSYNTGTKYGLVDLERIISALTFSPDGNIAIKPKGVIAIEHFLVLRNMMYRTIYNHRINEISTWILEKIIQIIKKDSVKKDLWIDESMRRWIFFPNQLEVKDFLANDDIVFYFHLMKWKEESFEPLKTLCKMFIDRKLLKASDISFLTKLKRLEILAFARKKCKLNNYDSEIFCGIKERSFKGFKSDNSLKIWDGTYQNLLENQSDLINTLMSSKDTSLIIYPGEFRKEIEDQIAIERANV,<ps2>,MSLKSVLKNKSLGILVHPSSLPGGSYCGTFGEGAKDWIKKLCKYKINHWQFLPLTPTDSTGSPYSSPSSFALNPWFLDINKLIEENFIISLNKKDLQSINQNEDHFDFDYANNLSKKLGEYLLFDWESQSEMRKTDFYLWNKKNTWVEDYSIFMVLREKFNMLPWWEWPLEFKQKENEFIKTWIKDKKNEILKTKLIQWHLDKQWKEIKVFAKTNGITLIGDLPFYVSRDSVDVWSNKSLFSISQNGDLLFQSGVPPDYFSSTGQLWGTPTYYWAKHKSTAFRWWRKRFKRQFELVDILRLDHFRALAGYWRVDGNAQNAINGSWINSPGKELLNLLKKDLKSDYLPIIAEDLGVITKDVEILRDNYELPGMKILQFAFDGNDNNPYLPKNIEKENWVVYTGTHDNATSTSWWDCLDITIKTHIKDKYKYSIDPSWNLMEIGMSTKANLFISPIQDILSLDDSSRLNTPGTITNNWRWKLNQTLDEIDMNLKKYSDLGNNYGRLSN,<
+<ps1>,MSIETKKYNNLISISTELRKRIIKTSYEAKIPHIGSCLSCIELLVFLYWKELNIDPSNSEAINRDRFILSKGHGAPALFQVLGLKGFFPIERLNSFGKPGSVFHEHPPKPGYIPGIEAATGSLGHGFPMAVGMSLAKRINNLQYRTYSILSDGECNEGSIWEAAMFAGAQKLDDLTIFIDFNKWQATGRSKEVLALDPLKEKWQSFGWDVYEIDGHKFNQIDKSIELAKTNKNKPSAIIAHTIKGKGVSFMEDNNNWHYKTPNEEEFKKAFEELKN,<ps2>,MSKFSSQEIESQYNLIKTLLSDPEKYNDALDAIKKDIAHMPLELKKKLEEENITF,<
+<ps1>,MQKKSFSISWGDTSLEMLPSKALLLPQTNELLICDVHLGKAEYFQQNGIPLTNNSDEQNLLSIKKIVENHKPYKLIILGDLFHSKYSISKSIKSKVENLSESLNIKIELIVGNHDIGCKVKNISFLEYKRSSNFIFSHEPIGKFENKILNICGHYHPKTFLKNSKDKLSFKCFAMDEKNNTLYLPAFGDLTGGYPCKNSFKKWAIISEKEIIAV,<ps2>,MKRLDLIFSERELDAIINTLEKANVPGYTVMKHATGRGPERVVTEDMEFTGLGSNAHVIVFCEQELIDQMRDNIKSDLSYYGGVAYISEATPL,<
+<ps1>,LEELITKKLEVNDNLKSRFHNGFNIVKSTFLSSPIALRLWSSFFVILPIFVQAPWVRFAPISALCATFFILAAAFLLSRKEGDKWFIVGSLLLGVTGSWLGGCLFWGWLSAYPILHIPVEAVALPLAIVGLGTKWKIGSSFYISSLFGTAITDLTIFLTGIMDQWKEVIIADSDNAPLILQKTSENLIQFKSLSIIILAALILWFISKEIFNYATSNSINGKAFLVSSYVIQTTLIVDGIFIMLAIIQPTLSGLV,<ps2>,LNRSFYFKFSVVIISFLLVWTLRDFILLIICSLVISNVVSNLCYQIQTILKLPRFVSLLIVLVGISFMIFAISIIVLPPFIREFNEILIDIPNGLSRVNELVNSNLNKFNDLIYGKESERIVNIFDLVNDVVPIPDGATIAKAIQESFINIINLAGNLGSGFIRVIFVLVVSFMISIEPKAYKEGVLFMIPKVYRNKFRIILDKCNIALTNWTFSIVISSISVGLLSLIVLSILDVKYVVSNAIIAMILNIIPNIGPVLSGIFPISIALLDNFWKPVAVFGAYIVIQNIESYIIMPSILKKKTNLLPGLTLISQFGFTFIFGPLGLVLSLPIVVVTQVLIKELINDN,<
+<ps1>,MSQIFTWIWVSSGILLILLVLLHSPKGDGMGGIAASGSSMFTSASSAEASLNKITWTILIIFLSLAIILSAGWI,<ps2>,MSKLKGPDGRIPDRLPDGRPAVAWERRWTEGTLPLWLVATAGGIAVIFVLGIFFYGSYQGVGAG,<
+<ps1>,MGEAKRREELGLPPREKKEAKKDSKSNLNQILNKYPFAPYILGISLLTILIIDLVNYYK,<ps2>,MASNKDNQLVEKNDDNLGVENISNNPSIQSEQKLEVTEDEISFKEEDLDNGFACFGFNKLILNSLESKGYKTPTPIQKAAIPELMLGRDLLGQAQTGTGKTAAFALPLIEKLENNKESNAKVLVMTPTRELATQVADSFKSYSAESTNLRTLAIYGGTDFRNQISSLKRKTDIVVGTPGRIMDHIRQGTFKINNISCLVLDEADEMLKMGFLEDIEWIIDKLPENKQMVLFSATMPNEIRNIAKKYLNEPAEILIKSVKQETQLITQKYINVQRHHKLDALKRILEITNEGVIIFVRTKLLTTSIAEALENSGHSVAVLNGDIPQNQRENTVDRLKKGFIDILVATDVAARGLDVERIKLVINYDFPFDKETYTHRIGRTGRAGRSGEAILFVNQREKHFLRNLENSTRNKIEEIEIPNNKIINEKRMGKLITNLNESSLDQENNEEKKALMIDILDTLREKHSMEDSNIAMAAINLAIGNKSFFINEDESWLYRQNNSDRNRSNRNGNNRMRNTNRRNNYQNDSFETYKFNFGKMDRVRVANIISSICTSTNINGRLIGKIQIFNEYSLVDLPRDLHGEVKNKLKNLRIRN,<
+<ps1>,MNSKLKFIYEGKAKKIFAYEDSDKVIIEFKDDATAFNALKKAKFEGKGELNCLISSKIFEFLIKNNIPTHYIGLKNNNSMIAQKIKIIPLEVVLRNTAYGSLCKQTTIKPGTVLESPLIDFYLKNDTLNDPLLTKDRINLLKIVDEEELDFISNMTLKINKLLKKFFYNIKLDLVDFKLEFGYNSNGQIVLGDEISPDNCRLWDLNQKNGMIVSLDKDRFRNDLGGFIEAYSEINKRINNFI,<ps2>,MGFVPLHNHSDYSLLDGASQVSKIVDRACELGMDSIALTDHGVMYGVLDLVKKCKSKGIKPIIGNEMYIINGSIDDPQPKKEKRYHLVVLAKNHTGYKNLVKLTTISHLNGMRGRGIFSRPCIDKSLLEKYNDGLIISTACLGGEIPQAILKGRIDVAENTAVWYKRIFGDDFYLEIQDHGSIEDRIVNVELIRIGKEHQIKVIATNDAHYISNMDVEAHDALLCVLTGKLISDEKRLRYTGTEYIKSEDEMLRLFNDHIDKESIKEAINNTVEVSQKIEEFELFGTYRMPKFPLKEETDSLSFLTKITKQGLLSRLNKNNLDEIDEIYKKRLTSELKIIDDMGFPDYFLVVWDYIKFARDSSIPVGPGRGSAAGSLVAYALQITNIDPVKHGLLFERFLNPARKSMPDIDTDFCIDRRNEVIDYVTNRYGEDKVAQIITFNKMTSKAVLKDVARVLDIPYGESDKLAKLIPVVRGKPYKLNEMIDKKSPSPEFRDKYLKDIKVKKWIDLALRIEGTNKTYGVHAAGVVIASDPLDMLVPLQRNNEGQIITQYSMDDIESLGLLKMDFLGLKNLTMIDKTISLIESSTGQKINIDKLPPKDNKTFDLIGRGDLEGVFQLESSGMKQVVKDFKPNSLEDISSILALYRPGPLDAGLIPKFINRKNGSEKIDFPHPFIESILTETYGIMVYQEQIMKIAQDLAGYSLGDADLLRRAMGKKKVSEMVKHRNIFIEGSCKKGVDKKIANDLFDQMVLFAEYCFNKSHSTAYGAVTYQTAFLKAHYPVAYMASLLSVNAGSSDKMQRYISNCYSMGIEVISPSINLSGIDFTIKKDQILFGLSAIKNLGDSAIRNIIDNRNKLGVFKSFSDLCDRLPSNILNKRNLESLIHCGALDEFSENNNRAQLFSDLEYVMEWASSRNRDRISGQGNLFDSISKNDTKEFSLSQGSKVEDYSLIEKLKLEKQLLGFYLSDHPLKHLAKPAKLVSPISISQLENSHDRTKVSLVGMIPELKQITTRKGDRMAIVQLEDLSGSCEAIVFPKTYCRLSEFLLTDTRLLVWGTIDKKSDKTQLIIDDCREIDNLKLLVINLDSSQASDIRIQNTIRDCLVKFKPDRDKCGIKIPVLAAVRNNDSITYVKFGDQFCVGDILGVSKLLSDKSFQVNLKSMIA,<
+<ps1>,MNIKQPSSHKNPEPESSVLYIVGTPIGNLSDLSSRAINILKNVSLIACEDTRQTKKIMNKFEFTNNLISFNKHNSLKKIPRIINDLNSGKSVALVSDAGMPSICDPGEDLVKNVRSNGSNIICIPGPCAALTALVSSGLPSSKFIFEGFLPKKKSQREKILFEISKNEKTTIIYESPHRLKKLLNELKIYCGGEREIQVSRELTKKFEEHIGNDINNVIKTFQEKEVIGELTIVIKGIKKESNLLINKSDLKKELNELIKAGLSLSAASKYLAKKHGIKKSETYNLN,<ps2>,MSFLNNWWLIPLIITIFSGILCPAMGTVLITHRRLLQVNLISHCVLPGLALALALGIHPSIGGVISGLVGAIIAESLTNKKSENYEAVMNTILAGMLGFGVLLIPLLGIRIDLEAVLFGDLLTANLGDLLRTIIAFLTFILLVTFGYEKVVYVGLDPEGASASGINVSLLNLALSFTTALVIVSSMSAVGVILVIALLSTPTLLGLDKAQSLRIAMMRSSFFGLCISLLGFILSIVFNLSPGPAISVICVASLIIPKIGNKF,<
+<ps1>,MAAKEHKSLQGSKILLIEDDKSIRLTVTESLISEGFEVSNFKDGSSALDFILGEGIKDFDLILLDLMLPGLNGLELCRKIRNEELYTPILILSAKGNESDRVLGLEVGADDYLTKPFGISELIARCRALLRRSKRGKEKKQKIETIIEYKNIKMFTEECRVTNFNQEIILSPKEFKLLELFIKNPKRVWSRDLILEKIWAIDFIGDTKTVDVHVRWLREKLEENPSAPKIIKTVRGFGYRFG,<ps2>,MRTILISGANSGIGLNIAHKELKAGNRISIGLRDLESVKGSVIDPNNWTNEKILLNKYDALDKFSAKKWVENTVSKFGGFDTLINCSGVLSKVPFLYKDGDEEEILNTFNINFLAIWHLCRISWKHLSQSNNGRIIVLVSMSGKRSKGDLAAYSSSKFALMSLCQTMKNKGWEENIRVTAICPSWVNTKMAEKISSIEKSKMTQPGDIAEICSTILKLPMQSVPFEIALNCNYEI,<
+<ps1>,VARIAGIDIPREKRVEIALTYIYGVGLTRSKLILSNTGVNPDIRVKDLSDSDVQKLRGATEDFTVEGDLRRKEGMAMKRLQDIGCVRGRRHRMSLPVRGQRTRTNARTRRGSRKTVAGRKK,<ps2>,MTLSSYRMHRIYLAATMGYGLGSDDPEEVAYYKKLRKEMDEMKKDVVKKGIPLTWDIPDGMDK,<
+<ps1>,MENSKPNYWQNAERTNGRMAMMGFFALVVNYGLFGWIIPGIF,<ps2>,MQILIIPIGFILWYFAYESKPINNDEVTSLWEKENYVKRTKLLNILKESF,<
+<ps1>,MDLCFLSTNITSFVADPLSHEFMRKALLMSSLVAAVCGFLSSYLTLKGWALMGDAVSHSVMPGVVVAYALGLPFSLGAFIFGVGSVALIGFVKQKSRVKEDTVIGLVFTGFFALGIVLVSKIKSNIDLHSILFGSPLGISLSDVKQTVFISLLVVILLSVFRKDLILYCFDPRHAKTVGINVLFLHYLLLTCLSLAAVVGLQSVGIVLVVAMLITPGATAYLLTDKFDNMTIISVISAIISSVFGIYFSFWFDLETGGSIVLVQTFIFLFAFLFAPRYGIFKFKKLFSSY,<ps2>,MKDMPTWIDEYHKGSRFGLNGKVLLKKNSKYQEILIIETDFYGKALMLDGCWMTSVRDEKYYHECLVHPALSSIDKKSHILIIGGGDGGTARECLKYSQVSKIDLVEIDEEVIKVSKTFLKEIGGGAWSDKRLAIHIDDGVKWVETTKDNSYDVIFIDCSDPSEFSNLLFTDSFYKECKRILTKKGILATQSESPESFENIHIHILKSLNKIFKLSETMYSFVPIYPSGIWSWTFASDEELNLSKVNYKEVMEIENNCDVWNLNFQNAAFKMMPNKIVKKLNS,<
+<ps1>,LQISNNNYPWPDDWGRKTSIMGIINLTPDSFSDGGDFCSIEKVLNQVNYFVSNGVDVIDLGAQSTRPGAIEIGAKNESKRLIPYLKKIRSEYPNILISIDTFNSEVAHEALSNGANWINDVTGGRRDEEILDVVSEFNCPFVITHSRGNSITMNNLTNYDDFLVDIIHSLESLTKKALNKNVSKDKIIWDPGIGFSKDTKQNIEILRNVPLLKNFEFPLLIGASRKRFIGEILNQPNPKERDIGTLAISCLCSQQKIHLVRVHNVKINYQVLKVADHIFR,<ps2>,VIPSDTPINQHSLQSLELWLKDLGATKDIDNPSKWYLLLSNWNATIIFEQEDLSVVWESGGKLTKRLFSYCINREDIENAILQGP,<
+<ps1>,MKAKPETTAHVSVKEYCFTKKEVKGVVEASDFKWTFTWSFGKGVLFVTPPLGRALIQDSLLRFFLKKDYELEAGNEYKFIISAKF,<ps2>,MDICLLNIDNNSNKSLNPTSVIGMLWLQTHFEDTQWEALSNNQVIISKENSKLLVKDAISAGLKIKSFSGVSMLDVFQKKN,<
+<ps1>,MKNKVFPFIKKYPMSILLAIIAINLFSIASSLRTEAYLNREKNLCIKYLKHQIDRDTLIKKLRIVKQANPSSICDSVLKS,<ps2>,MNKFEFFKTDAIQSSYGGQFSYKVIGPCCRLYDREELPWPCSRLAWRSKEPSWRRIGARFVADMASRKCPSYSVQILEPGSKPVETVITLFSKKFSSEIQEWWYSKKPGSKEPGNVLPESI,<
+<ps1>,MDYKTSGVDIKAGREFVSEIKQSVESTYSSNVLEGIGGFGGLFKIPLEGLKKPVLVSGTDGVGTKLELAQIKNFHFEVGIDLVAMCMNDIITTGAKPLFFLDYIATGKLEKNQLLEVINGIAHSCRENKCSILGGETAEMPGFYSKNKYDLAGFCVGIADEEKLINGKKICENDLIIALQSNGMHSNGFSLVRKIIENNNQIDKQFEKKYNLDFYDELLKPTKIYFKIVNQILSQNIQIKGMSHITGGGIPENLPRCMSSDFIPYIDKKSWKIPVLFEFLKDVGQIPEKDFWNTFNLGVGFCLIIDKKYKDKILNICNAFDISSWVLGKVLKKNNSKENNFLPEIII,<ps2>,MYFQDIIQNLNKFWSEEGCLIMQPYDTEKGAGTMNPHTFLRAIGPEPWSVAYAEPCRRPTDGRFGDNPNRAQHYFQYQVIIKPSPDEIQEKYLTSLEFLGINPKDHDIRFVEDNWESPTLGAWGVGWEVWLDGMEVTQFTYFQQCGGIDCNPIPIEITYGLERIAMFLQDKESIWDLNWNKDINYSDIWLQFEKNQCSFNFSNSNPENMRKLFAIYQEEANSLIEKDLTYPALDFVLKCSHCFNLLDARGVISVTDRAQYIEKIRKLAREVATSWIKERELMNFPLVKK,<
+<ps1>,MKNFTKNNYSTKRNDTENRRSQSKNNFKKGNDLNTRDDSNRRDNSNRRDNSNRRDNSNKRDNSNRRDDLNRRDDFNRRDNFKRRDDSKRRDNFKSRDDLNRRYDFNRRDNFKRRDDSNRRDDFKRRDDYERKGAIKSNEYSYLKSKEKPRNSFNQSQTRFSSNAQQTENYSENSSKKFQLSPNERNYEDWIWGKHSVFAALNSERPINRIWCTSEIFSSEKFYLLLKDLKSKGVLIEEVPWSRLSQLTSGAVHQGVALQHASTESISLEKLIDISKSKSSNPIIVALDGVTDPHNFGAIIRSAEAFDCKGIIVPQRRSAGLTGTVAKVAAGALEHIPVSRVVNLNRAIDELKKKGFIIIGLSGDGQVPISEFKEKAPVVVIVGAENKGISLLVQKKCDYLLKIPLKGKTSSLNASVAAAISLCYLSNN,<ps2>,MELPCRRFGRTNLKMPVLSLGGMRFQKSWDELKFSEISRKEQNKVENILNLANKFGFNHIETAKYYGTSEIQLGMGFKSIEKKPKIIQTKIPPNRDPKLFEAELLKSFEKLQVKKIDLLAIHGINTPEHLHQAVKDGGCIDILKKFQQENLIGYIGFSTHGELSLIEKAITTNLFDYINLHWYFINQTNSKLIELAHKYDLGVFIISPTDKGGHLHTPSTKILELCSPLHPIVFNDLFCLRNKYVHTISVGIAKEQDFNLHLEAVSLLSESDHYIPKILNRLKEESINSLGIEWYKSWDKNLPNWKNTPGGINIPVLLWLANLIDSFDLEEFAKSRYQLLGNGSHWFPGNNANLLDVNVCESQLLKVLERHIKPKKVIKKLRVLKDKFGDKSLKRLSKN,<
+<ps1>,MSESKSPLDRIYRLIASHAWMTENEAKVLLVMMYASGTKSLGLEGKGLNKFMERSLEKMCSDNKENLQEYLLKIKDKFPNNELLSED,<ps2>,MEPTSSLNRGDRKKGSSLVTGSEVQSQSNGASCFITTDSEKSLVSRQASQVEQIELRTYVFLDSLQPQLAAYMGTVSRGFLPIPGDSCLWMEVSPGMAVHRVTDIALKASNVRLGQMIVERAFGSLALYHKDQSTVLHSGDVVLDAIGSEVRKRTKPSTSWTEVICAITPDHAVLINRQNRSGSMIQSGMSMFILETEPAGYVLKAANEAEKSANITIIDVKAVGAFGRLTLAGKEGDVEEAAAAAIRAIDQISNY,<
+<ps1>,MTMNNLKTKKLVNLGPSGRAVAQPMDVSLLDNFYEHLTMERYANVQYFSIYLWFQERDLDGFASHFLSESQGEMEHAYKFANYFIARGQTVKLKELPAPIQTWDSIEDIISYSFNMEADLTSSLQQLYSISERISDTRTSVFLDPIVDAQTKSEDEFAHILGKVKFAANQPSAILLIDSDLKKK,<ps2>,MFLKDHLKDTYQKASFDNNHLMLENIINIWAHRFGPESLNELFVKDQDQDQLKLIEENQAEASQNQINLELIEDHQSEANQNQTNLELIEEHQSEVNQNQINLELLKNLQYEEKIEFKPKETKKSNNTEIINKDIYGSYKNESEFKDKEELPLPNIKNLRKWINNEKKAS,<
+<ps1>,MIILHIGLFENSFSNIMKSVIFQETANLKKPVPAEKVIELSDKLLEPSSHSKRYPPRLHKTWGTIFFMIAIHLLSLLALQPQFWSMPAVTALFFFYWLTACLGVTLGYHRLLSHRSFVVPKWLERFFATCGAISCQHGPIDWVGLHRHHHSFSDTEVDHHNSKRGFWWSHMGWMFKDVEALKAVPKLSADLIKDPYYRFLNKYFLFLQIPIGLCLYAIGQKLGVGGWALVLWGIPLRLVVVYHITWLVNSATHCWGKAPFESGDGSKNNAWVAALTFGEGWHNNHHAFPNSARQGLFRGQIDLTWEHIKILAKLGFAKKVKLPSRSYY,<ps2>,LNKKLGHKDHFHFIGIGGIGMSAIAMALIKKGYSVSGSDLIQNKETKSLKTLGAIIFDSQIKKNIDFVISKFQDHTLNCVISSAIKDENEELCFCKKNNLSIKHRSEILAMIMNSYTSLSIAGSHGKTSTSTFLSTLLELCTHDSSSITGGIIPIYDSNAHIENTKYLVTEIDESDGTIKNYNSDIGIINNIDFDHCDHYSNIDEVLSSFKKFASNCQKLLINYDCKFTKNNFTSKNQWSIKESNNIAYSLIPNIINKDKTVGKYYEHGKFIDIINIPVPGLHNLSNITAAIAACRMVGVSFKEIKKNTESLKLPKKRFEFRGEINQRIIYDDYAHHPNEIKATIDLARLFIKDKNSSDREEKGRLIAIFQPHRFTRVKQFIHEFVKELSKADVIYVTNIFGAGEKNIDNIDSQLIANLIYKNNKNVTCLKDNYEINEKFFKLTKKNDFIINMGAGDCHNLWSILKNKNTLNN,<
+<ps1>,MDINWASTQIVKNLDRHEKRDLLAWILTQSERTFQRAFEAGQYSSAIGSLKLIWEMTIKDSKEKDSRYHGNYKH,<ps2>,MSKLHLKRFLKKSYEFSLVLFQFFIIILHFIHLEFIPKKEIMQVNFFFSFVGFLLIIISTIVMLISIKDLGRNLSPFPRPTVNGNLTTSGIYSFIRHPMYYSLILISFGFFITKLSFYHLFLTISLALIIKLKIILEEKYLNKKFKNYFIYTDKVKY,<
+<ps1>,VHKNKILVPLSNNSYEVIIKQGLINNIGEELIRIGINSNRKILIVSNKEISTLFGRKLLNNLKKNNFNAEIFNIKAGESHKNFASLSEIFNAAFEVGLDRNSLLIALGGGIVGDVTGFAAATWLRGIEYIQIPTTLLSMVDSSVGGKTAVNHPKGKNLIGAFYQPKAVFIDPETLITLPTREFKAGMAEVIKYGVIKDKSLFEYLENEKNRDKILNLENESLIKIINKSIKTKACIVSEDEKENGIRAILNYGHSFGHVIENLCGYGEYLHGEAISIGMKIAGDIATEKNLWSKEHSLRQDHLIESYGLPIQTPKIKKNDVMKILMGDKKVRNGKMRFILPIELGEVDIFNDINESQFLKYFN,<ps2>,MKKIWKIEKLVLPQHSDHAGVMWHGTYFDWLEEGRINALSKAGLNYVDLTKNGFDLPLIDTSIKYISPLFLGDTVTIETIFEISKSPKIKIHSKFINKSKTILTIAKVNLVLINKKSFSIIRKRPDFISKAFLKLNG,<
+<ps1>,MNDLNIEFPLDDFEELISQIGWSSLDEWFIFWNLKKEMLSINNFWDDNVKDDWIWGLALPLLSQAYKLNKKSPDRKIIGISALPGTGKTTLGKWLESISLKLKFKLSVISIDDFYLPSEEMEFAIKNNPWNVSRGFPGSHSIDLMKEKLLKWKTDGQLNVPVFDKSLRKGLGDRAHWREESPDLLIIEGWFLGVKPLSIDLDNSEKFSPPLSVFESSYRNKIQNNLDQYLDIWNMIDQIWHLKPLKFEYLNEWKSNQEKSMHFKSGSSLKGDNLSNFLRMLNVSIPHKSFDDINSDVLLMINQERKLVRVGLNQQISK,<ps2>,MLTTKITYALSDWIREWRKCRKENPSLDDCIKFTEWKIENYELTDSDRMIIESILLYETEET,<
+<ps1>,VNITFLGTSSGVPTLTRNVSSLALKLSQTAEVWLFDCGEGTQHQLMKSNIKSSQIKKIFITHMHGDHIYGLPGLLATLGLSGNSNGIEIYGPSELKSFVTSALESSFCKLSFPLRFRAVEDFASLNKILFENDKLKVHCACLKHRLPAYGYRVSEKDKPGVFDIKKAEDSNIPPGPIYSELQAGKTVQLKDGRSFNGQDFCGPPRKGESFVYCTDTVFSKSAVNLSKNADLLVHESTFSKEDEKMAYEKLHSTTIMAAKTALLSNVKKLIITHLSPRYTQRSSIKPSDLLKEAQKIFPNTYLAKDFLTAEIK,<ps2>,MKLSKKFEELIIKQLESFGCSMGVTHLVMYLASTEQGTKASFEMIGQWPQIDRLLVSVEDDPSLKVSSPNRRWYPLQENDILLGVLRVETDLKEGNWPVSLDSRLKALSLSLAKCVSIELERQNKNEEINYLKSQVNVIIHQLRNPLAALRTYAKLLIKRLGSDVDSIEIVERMIIEQKQINNYMDSFAQLNSPIQLPLDIGEERLLLPPNLDNKKLITVQSLLRPILERGQANANLENRDWTEPSLWPDWTLSPLKAKYAVIAEIVANLLENAFKYAHKDAEIGVAIMSKGLCIFDDGKKITKIENEKIFQKGFRGSAAKKKDGTGVGLFLARKLAKQIGGELRLLENSSINDVEELKSFKKKNIFYLELPIKELHS,<
+<ps1>,MIENPSQIVKEISDEKEIENSTIEENTSDTPKEEDLSFDHKDIPSADSSSSRRNNDLDTAGFTQEEFASLLGKYDYNFKPGDLVKGTVFALEPKGAMIDIGAKTAAFMPMQEVSINRVEGLSDVLQPSESREFFIMSEENEDGQLALSIRRIEYQRAWERVRQLQKEDATIYSEVFATNRGGALVRVEGLRGFIPGSHISARKIKEDLEGEYLPLKFLEVDEERNRLVLSHRRALVEKKMNRLEVGEVVIGSVKGIKPYGAFIDIGGVSGLLHISEISHEHIETPHNVLNVNDQMKVMIIDLDSERGRISLSTKALEPEPGDMLTDPQKVFNKAEEMAAKYKQMLLEQTDENEEQTVEIAESV,<ps2>,LSRSLDLPSTEGVDTLAQELAKLQDNGKRRIAFLGSRHVPVVDIHLIELIARSLAEEGHTILTSGSQGVNAAVIRAVLGINPSLLTVLLPQSLDKQLPEIKNQLESVIHLVEKSENDELPLPMASSLCNQEIINRCDQLICFAFHDSETLLNSCRCAEEMGKVVSLLFFD,<
+<ps1>,MKKKLAAVSFSALLAIVASSTTSGFASWNTKYWTNEKNFNRISSFNVSENLPEGSKSTTKTSSEVVTASEDGKTLMYTDSDLGVVGLVDISDPAKPKALGIVELEAEPTGIAALGNNIYIGSNTSESYTNPSGALVQYNLDKRRAVKECDLGGQPDSVFVSPDGSFLAVAIENERDEEYKDGQIPQLDEDGKQINPAGYVSLVKLNKKGKIQCNSIKKVDLTGLASIAPSDPEPEFVAINDLGETVVSIQENNHLAVIDKEGKVISHFTAGIVKQMAGMDTKKDGAHKFKKKLKNVRREPDGLTWIDNDHFATANEGDYKHKAPGQAKRGGSRSWTIFKKDGTVVYEDANRLERSIAQIGHFQDGRAGKKGVEPESVTFGKIDGTPYLFVGAERAGIVAVYDITELSQPVLTQLLPSGIGPEGFVAIPDRGLIASANEKDYNKKEPGLSSHVTIYQLQDAPASYPHLTNENGLEFVSWGAISGMVSGEDGKIYAVNDGTFKTQPRIYVIDPSSSPALLERAIDIKLDGKTALFMDQEGITTDGRGGFYISTEGIKKKLTEHPPAIYHVSSEGDILEKITPPPSYLNYAKNPGFEGITRNGNILYIAQQKPWGDDTFNTTKILSYNLISKQWGAVNYQLDRIKKGGVGISELTYHDGALYVIERDSFYGKKAKLKAIYKVDLDGVVFEGLQTTMPPRLYPLVEKELVTDLKPVMKSTGGFILEKVEGLAINNDGQAWISTDNDGTGKKSTGETLFLNIGKI,<ps2>,MKNLKSNKRKIHRKVAAISSIPLLITLISGTIYSFLQPLGVDAFWLIKWHTGNFGIINLQPFYSIFLGIASIISVISGIRLLQKNS,<
+<ps1>,MGFIKNKLFIFIILILLQSCSGGRIGNFFESSFKNIEETKIKEDVKNNLKNKIVIKSGGIVEKNKNIEETKIKEDVKNNLKNKIVIKSGGIVEKNKNIEETKIKEDVKNNLKNKVLKMSEKKSKNNKKISDKNISPKKIIFQPKSYKIIFILKDVDPKDPTEDLRAILRNSDVNFEIEKIERYFDTKNKTIKSN,<ps2>,MKWIIQEEKEEDHLQILNKDSEIGIDEVGRGSVFGPVFSVAVVLSKKSGLTLKKLGVNDSKKLTPKKRKDFFPKIIALSSDYALGQSSVREIDLLGIRHATELSMIRAVKKLKHMPSELLIDGPLTLRLWEGNQRNIISGDSKFISIATASIIAKVMRDSLMERLESKYPGYFIFKNKGYGTKQHFSSLKKHGLTNLHRKSFLNKLNLI,<
+<ps1>,MELPCRRFGRTNLKMPVLSLGGMRFQKSWDELKFSEISRKEQNKVENILNLANKFGFNHIETAKYYGTSEIQLGMGFKSIEKKPKIIQTKIPPNRDPKLFEAELLKSFEKLQVKKIDLLAIHGINTPEHLHQAVKDGGCIDILKKFQQENLIGYIGFSTHGELSLIEKAITTNLFDYINLHWYFINQTNSKLIELAHKYDLGVFIISPTDKGGHLHTPSTKILELCSPLHPIVFNDLFCLRNKYVHTISVGIAKEQDFNLHLEAVSLLSESDHYIPKILNRLKEESINSLGIEWYKSWDKNLPNWKNTPGGINIPVLLWLANLIDSFDLEEFAKSRYQLLGNGSHWFPGNNANLLDVNVCESQLLKVLERHIKPKKVIKKLRVLKDKFGDKSLKRLSKN,<ps2>,MIFRNKRSSIKKTNILSQDELIKHYGINSYEFTHQEKKEIFVCSKVKEFDLIELDQLLQTVGWSRRPIRRVKRALEFSILVVGLWRHDEKFPRLVGFARCTGDGIIEATIWDVAINPVYQGLGLGKELMKYILQELKKIGISKVTLFADAEVVSFYKRQGWELEPKGSKCAFWYAN,<
+<ps1>,MIIIEGFHIFNHKQNCKTKAEWMEQSGMTYDRESEVN,<ps2>,MQIKILVKLFSHLIKVIFKPLLGFAKFFITTYGVFLKFFLQLNGGYWGKIGIGQYSKIERKRFFCILPFYILLALLFGILSLIYWYFVVLFIPFWIERYLTDTAQWNNIFSSIMAFALICGWLLLLSKTK,<
+<ps1>,VEGKNTSITFDGREIRLTTGLYAPQAGGAVMIECGDTSLLVTATKTTKKQAADFLPLICDYEEKLYAAGRIPGGFMRREGRPPERATLIARLIDRPMRPLFPSWMRDEIQIVASCLSLDERVPADVLGVTGASIATLLAEIPFYGPMAAVRVGLIGDDFILNPSYREIEKGDLDIVVAGSPEGIVMIEAGANQLSEQDTIEAIDFGYEAVSELIKAQENLLKDLGIKQVKPLEPEEDKALATYLEKNCTKPIDLILKKFDQSKEERDLELDKIELEVQTKIDSLKDDNQLKVLTSENEKLIHSDFKKLTKKLMRSQIINEGKRVDGRDLDEVRKISASAGILPKRVHGSALFQRGLTQVLSTTTLGTPSDAQEMDDLNPSTEKTYLHHYNFPPYSVGETRPMRTPGRREIGHGALAERAITPVLPGKETFPYVLRVVSEVLSSNGSTSMGSVCGSTLSLLDAGVPLKAPVSGTAMGLIKEGKEVRILTDIQGIEDFLGDMDFKVAGTEKGITALQMDMKITGLPVSVISDAIKKARPARLHILEKMQEAIDKPQESLSPHAPRLLSFRIDPELIGTVIGPGGRTIKGITERTNTKIDIEDGGIVTIASHDGAAAEEAQKIIEGLTRKVHEGEIFPGVVTRIIPIGAFVEILPGKEGMVHISQLSEARVERVEDVVRQGDEVTVRVREIDSRGRINLTLRGVAQNGGMSYPEPTPTPVAPLN,<ps2>,MPKQLSFSNESREALEKGINTVANAVKVTIGPKAKNVVIERKFGSPDIVRDGSTVAKEINLDNPISNLGAKLIEQVASKTKESAGDGTTTATILTQIMVQEGLKNIAAGASPIELKKGMEKGLNFVLEKLRSKSIKINGSDIKKVATVSAGGDEDIGSIISKAMDIVTSDGVITVEESQSLETELDITEGMSFDRGYSSPYFVTDQERQICELENPKILITDQKISTLTNLVPILEEVQKSASPFLILAEDIEGEALTTLVLNKNSGVLNVSAVRAPSFGERRKAALEDIAILTGAKLISEDQSMKLEEVTLNDLGKAKKITISKDKTTIVAFDDTKDLVQERVEKLKREVEITESEYDKDKINERIAKLAGGVALIKVGAATETEMKYKKLRIEDSLNATKAAIEEGVVSGGGQTLIEISNELSNSRKEISDDLTTGIDIITNALLEPTKQIAKNAGFNGDVVIADIKRLGKGFNANNGEYENLNESGILDPTKVIRLALQDSVSIAAMIITTEVAVADIPEPEAAPGGPGADPMGGMGGMGGMGGMGGMGMPGMGGMGMPGMGGMGMPGMGGMGMPGMM,<
+<ps1>,MILSLLLSTFITIFIAELGDKTQLATLTMSGTSNKPLAVFLGSSSALVLASLVGALAGGSISNFLPEIILKSIASITFFIIGIRLFVNSFTSKENDNNQ,<ps2>,LKNLLGCSVKDLEKIALNYGQAAFRGRQIYNWLYNYKNRSKSIDEINVLPLKFRDQLKNEAFLFGELTLKEKYLATDGTLKLLLNTRDNESVECVGIPTEKRLTACLSSQVGCPMDCKFCATGKEGLKRSLKVSEILDQILFIENQMNQKVSNIVFMGMGEPLLNIDELLLSIRSINEDFAISQRKITVSTVAIPKMISKLSELSFQVLGKCQFTLAISLHASNQKIREAIIPSAKNYHIKNIIDDCREYVRETGRRVSFEYLMLHGVNDKLEHADELSNLIKGFQCHVNLIQYNHIEEVEFKQTPIKNAQLFQTRLSNSGINVSFRKSRGSDRNAACGQLRQNDKIK,<
+<ps1>,MYSLEISLRYSPFPLSIQKKEYEDIKRIYDEIKDSMNSDNQNSPLIELSCEKVQDKLITVLAKEVISVQIYEKSAVAGGSKRPGFSLDI,<ps2>,LARDFPLERVRNIGIAAHIDAGKTTTTERILFYSGVVHKIGEVHDGAAVTDWMAQERERGITITAAAISTSWQDHRINIIDTPGHVDFTIEVERSMRVLDGVIAVFCAVGGVQPQSETVWRQADRYSVPRMVFVNKMDRTGADFLKVNQQIKDRLKANAFPIQLPIGAEGDLSGIIDLVSNKAYLYKNDLGTDIEEAPIPDEMKDEALEWRSKLMESVAENDEELIEIFLDKGELTEDQLKKGIREGVLKHGLVPVLCGSAFKNKGVQLVLDAVVDYLPAPIDVKPIQGVLPNGKEDVRPSDDNAPFSALAFKVMSDPYGKLTFVRMYSGVLSKGSYVMNSTKDAKERISRLVILKADEREEVDELRAGDLGAVLGLKNTTTGDTLCNTDDPIVLETLFIPEPVISVAVEPKTKGDMEKLSKALQALSEEDPTFRVSTDQETNQTVIAGMGELHLEILVDRMLREFKVEANIGAPQVSYRETIRSSSKGEGKYARQTGGKGQYGHVVIEMEPAEVGKGFEFVNKIVGGTVPKEYIGPASNGMKETCESGVLAGYPLIDVKVTLVDGSFHDVDSSEMAFKIAGSMAFKDGVKKCNPVLLEPMMKVEVESPDDFLGSVIGDLSSRRGQVEGQSVDDGLSKVQAKVPLAEMFGYATQLRSMTQGRGIFSMEFANYEEVPRNVAEAIISKNQGNS,<
+<ps1>,VKKSLFKPSRKFTLFSAFVTLLNDRLSESILLPILPSFVLLFDSKASTYGLLSCTYQLAQFTASPFIGLMSDRYGRRPVTLFCITGSIIGISILSFTVLFDWSTSLATIPLFLLFIARLIDGLSGGTAATATTILADISSPEKRAKTFGLIGVAFGLSFFLGNIFVVIFAKNTNNNFIIPVIIASIIPIINFILVFFYLPETKPQNELNKSTQILKNPLKQLFKVFKEEKIRKLSLAFFIYFIAFTGLTNILIFFLQESLNWTTKASSGTLVVVGVIAIIVQGGLIGPLVKKFGEMRLTLIGSGFILLACFLLITTPQKNAIVNIYSAVSFLAVGAGLITPTLRALISKKLDGDNQGSILSNLQGLQSLGGVLGIGMAGKVYDDFGPKAPFIAGSIILLFMIYLIAEGKNNNISYN,<ps2>,MTDIFEVPTPDNELLEKAKQLRLASIKTSQTNNDDRIRALNLMADYLEKNSKEIIEANIEDYKKAEIKGISKSLLSRLKLSKEKLNLGIEGVRQVGNLIDPVGQIQIKRELSKGLILERKTVPIGVLGVIFESRPDAVMQISSLAIRSGNGVMLKGGSEANLTNLAIVSALKEGLQDSNLDENAICLLTSRKDSMAMLNLEKYINLIIPRGSNELVKFIQENTEIPVLGHADGICHLYIDNEVNLDMALKVALDSKIQYPAACNAVETLLIHKDTASEFLNKAIPMFNSNDVKLIGDKKSFQLGVAFEANYEDWQTEYLDLILSIKIVNDLEEAIAHIQKFSSKHTDGIITENINNANKFMSEIDSSGVFHNCSTRFADGFRYGFGAEVGISTQTLPPRGPVGLEGLVTYKYFLRGEGHIVDDFSSGKLIYSHKDV,<
+<ps1>,MQNITFKGNVNFDNQKEELNENELFSLKITDSLYKKDIGKFLEILSSHFIP,<ps2>,MRVVIAGAGLAGLSCAKYLVDNGHIPIVLEARDVLGGKVAAWKDEDGDWYETGLHIFFGAYPNMLQLFKELDIEDRLQWKSHSMIFNQPSEPGTYSRFDFPDIPAPANGVTAILSNNDMLSWNEKILFGLGLVPAMLRGQKYLDKCDSKSWTEWLKEHNIPERVNDEVFIAMSKALNFIGPDEISSTVLLTALNRFLQEKNGSKMAFLDGAPPERLCQPMVDYITERGGEVHMNSPLRKIDLNEDSTVKSFTIAPLDSDEKKKVITADAYVSAMPVDLFKLIIPDQWKGINAFSKLDGLIGVPVINIHLWFDKKLTDIDHLLFSRSPLLSVYADMSITCKEYEDPNRSMLELVFAPAKEWINRSDQDIVDATMEELKKLFPTHFIGDDKTKLRKFKVVKTPRSVYKAVPGCQEFRPSQRSPIKNFFLAGDYTMQKYLASMEGAVLSGKLCAETINKEYSKTSNIVSRETSKIN,<
+<ps1>,MLENIWHPSYSAAEYLGITEIKLSHLRENGYFKPGIHWKSSPLGQKKPWNPEVLYNSILCRKIMDEFYSEEKNDQYAA,<ps2>,MRNLIKENIKKTGNNSSRSIKKLLKQRSFVVFISILLTGLGASITSISFKTGIYFINNWRLELLNHFPSVAVLPLFGAVGGAIAGFLIKNFAPAAKGSGVSQIMGFLRHKKVPMNLKVGLVKLISGIIAIGSGFPLGPEGPSVQMGGSVAWQMARWLKAPLAFRRVIVAAGGGAGIAAVFSAPLGGFIYAIEELLNSARPVILLLVVITTFIADSSADIIQALGLDPKAGGFDFNLGFLIQKEYDPSVFFLPIDFIYLVLLGIIIGLFAELYSKYVLFMQKLGKKWYKNKFVLKMSICGLLLGSIYSFLPSSFHNLDELQKIIVEKNTNIEIAFLAVFILFITTGLAAASGAPGGLFYPMLTLGGAIGLIMGTWVEIATGHAPSTYIFAGMGAFVAGCSRTPITAMFLAFALTKNLLIMKPVLISCIASFLVARAFNEESIYERQIQIELED,<
+<ps1>,MKKKSITYTDLSKKQLQHLKELYIQKKVECMSHKELKEFVLEIISHQINDTIGKEEEMEAWMEMSKFYGDQFEIIILEIQQKFANNENLQNFEEDSKEHRLELLEKNNIEQNKQDMWDD,<ps2>,MKEIGWPTIDSKHLVVYSKQMLDLENEIFSQGMPQEALMEKVGIQLSKWLLKRKSLLKKGVIVFLGPGHNGGDGAVIAKELFLKGYLVKLWCPFPLKKTITINYVNYLTSLGVEILGDSPNPEGKDLWIDAIFGNNQKRKVDEELIELFNKKFEKRSGKVVSIDVPTGLCPNSGKPFLKNAVKADFNLVVGLNKIGLLQDTALPYVGELHHIDIGICRSQLCKLESKILKISYQDLRTIKLPLLPKNSSKYKRGRTLVIAGSEKYPGAAYLAIKGAISSGAGFVSAIIPNLVSNSIWQVEPEVVVTGSLSSDKNGNSILFNALKNVDFSAYDSIVIGPGIGLNEEDWEKSTQYLLDLKGLLILDADALNRISKSNLGPKFFLERKSKTWITPHNKEFMRLFPEIDCTNKVELAKKAAKAFDISILLKGANSVIANNENAWQLFGTDAETSRAGLGDLLSGFIGGCSSIELSSRDYTKTESLAKYVFLHSFAASKCKKGSNASLIGAQLSKLMRKTKTRLMS,<
+<ps1>,MRQHVNPLSKNFFEIDPIPPLNQVFENPKLPLHLDIGCASGEFLFELSLKNKNWNYIGIEIREKLVLNANLKMKSRENKNLYFSFGNANNIFNQTNNKSIINLITSISFNFPDPWFKKKHHKRRVIQPKLLNLLSNSMKKGSLIFIKTDVRDLFDHMELTISESIKFKKIPYQDVDFCESFNPNRIQTNREKYVILNQLKIYESIYKKI,<ps2>,MTDDINPIESDFNAALSRYQDGQELIPIAQDFQKIIQQIPNHFAAWTCLSWLQLLLKNNEEALAAAREAVRLNQQDPQARMNLSLALLATNNKGVRDHVELIKKMAMMMPDVKTELKESVEDGFNRYPNWPELTKINKWLEF,<
+<ps1>,VLNDTLSSKFICFHLINISNKLNSTLKIELANPNKSEMFELKSYEKFRDTEDVRFFDISINNSNFRDLVIHNGPAVSPPNDKELGNWQFYIHHKQEDNLLAISGGRTFYLVNLGWEYPFYKVRLESCGLILKIPRGTFHRSVSDENGSVVLNQAIRDKGGSVESEFKVTNSKDNKKLHDCITNLQPKFKIYSVK,<ps2>,LIMSLIPLLPVFHKFNRQFFDQSLTTNREPLVKVRWSDNRLKTTAGFYKRKQLKGVIDSEIILSKPILSKLSCNEIHSTLCHEMIHAWVDRILNINEIHGPNFLSKMNEINKAENNFQISIRHNFPVERKALKYTGKCLNCGEKYMYRKRIKNIACKKCCNLFFNGSWNKKCLILFD,<
+<ps1>,MIKDHPIFLESIRFIKSNLIENNFNYLENRVLERLVHTSGDFNIQKLLEFSEGACEKGVKSLKAGAPILTDTDMAAAAIKSMAKNTNGNLVVSAKHWFDDRDLSELTKTAYGIEKGWIELSANNSGNQSPIIVIGSSPTALVNLLEIIQNSQQIPSLIIGMPVGFIGVRQSKNKLLNTNYPRIVMNSTRGGAAMAAAAVNALLRESI,<ps2>,MREEDIKSFEDAFFDALNLFNNQKWYEAHDAFEDIWNTLEGDERQIIQGIIQVSVSQFHLSKGNLNGATILMGEGLGRIKNRTNIDLGVDLVSFCKCLDELLRKLQYKEELTKNDKPYLLIKEQNEF,<
+<ps1>,MRVKLEPETAFIGKKFAYIFLGIIFALNSIVFIWYFFFSNLTWS,<ps2>,LFQSLFSTKYNYFYNIYIVFHIRTSILLLSGLVLGLWTSWPGIVIPNNWKCFKDMIEKSSKE,<
+<ps1>,VSENIQPSSEENQIVEDLTNKESPEKLPEFKDKELITNLEQNRFECRSCGYIYDPIEGNKKLNIPKNTPFSAIDGNTFACPVCRAGKNLYKDIGPREKPSGFEENLTYGFGFNSLPPGQKNILIFGGLAFAAACFLSLYSLH,<ps2>,LIGIFSAFGAAISWTYACFIWRSQTEKYKSIDINLVKNIIAFLIFLPAFINLSVLNNLKSIITLLFSGVIGIGLGDTFYIKSLQLIGTRRTLSIETLSPILAALSGEIFINENLAFRSYQGILIISISLFILLRQRTNLIVNNLTNITERNNLSVYVFPFLSVLCAVSGGLLSRKVFLESNLSPFQATEIRLLGAIIFLIIIKKFRINFFLKKLDFNDQKRFLLSILLGTNLGILLQQIVFKTLPLGIGWTLLSTSPVISLFFATKEEGQITKGIIFFTTLLFLGLCLIII,<
+<ps1>,MKILLSVFFLFAFIPPSKGVTTKMFKVLDTCARYRLGEIDAKQAIEKLKLKSVNSSEIDLKNIVSNYCSVFTPNENIKF,<ps2>,MPKKHPTRRQFLNFGKLSLLFFLNSCSNSLKKIKIGFQSSTYPKSFRDTFPAIWQKENINFSKLKLEKNKIKFSKSDFILINDGWLKSINFANFQNINNLFLNDLLDNRSRDYLKSFKEYQRNKLFPIGVVPYAVIIKNNKDLIYEASNNWDFLLDEKLKGKIIFPQSPRILISISKRINVKNSLSKLKEQAMLFDDKNSINWLINSDASVAIIPFSLCEKYLRVDSRLSMVFPNKGVPLMWNFLLTKSKINNIVLFDWIKSLEKRSTIDELANQGWYLPFKNEYSQDKYNIKTENSNYGPSENCWENSWSFSSLNYEEKVNLENLWNQS,<
+<ps1>,MRFKVSLKKDGKEFDEVVIANNKKDAIEVALKNNPEAEVLNSDWTFKL,<ps2>,MNDHNSKDNYEAQTLILNDSNGNELFCYLEQIVKVEEKEYALLTPVDTPVSLFKINENDEPELIEKIEKNEQVLKNADAVLQEHDLKLIRSAVTLTVSGELEEPIYDELEEDGIEEESETYELLVSFNLLEQEYGLYIPLDPFFIVGKLINQGALLIEDDEFDKVQPLIESELEKSSF,<
+<ps1>,MENSKPNYWQNAERTNGRMAMMGFFALVVNYGLFGWIIPGIF,<ps2>,LMNKYDVIIIGSGIGGLCCGSLLALAGKKVLIAEAHSQPGGVAHSFNMRGYKFESGPSLWSGIGKWPTTNPLGQILRLLDEKVELIKYQGWHVNVPEGEFNLEVGQEPFKERIRLLRGEKSVKEWDSFVSGIRPLSQIVSEIPLLSSSPETINFLEIIKLASKFLPNIKSLPKLNGGFGDIVDSHLNDPFLRNWVDLLSFLISGMPMHDTNSAAMATLFDEWFKPASYLEYPKGGSESIVKALVDSFKKNGGELILSSKVEAVNFSKNIASGVTLENGSNFISNFVVMNTDAWTSRKLIPQEFQKKWSPKAKDINKCGSFLHIHLGFDASGLQNLPIHAIHVDNWERGITAERNVAVFSIPSVLDKSMAPKGKHVLHGYTPANEPWEIWKNLKSNELAYKELKEERCSIFLKSLRKIIPDIDNRIEIKLLGTPLTHKKYTNTYCGSYGPALSAAQGLFPGCKTSVRNLLTCGASTFPGIGIPAVSASGAYAAEKIMGKKEYKKLLKTIDL,<
+<ps1>,VFFKSNFSYSDSNKSYSDLLLELDSGNIQSIYFYPRKREIDVLYKNGNKEKIPILYNDQLILEKASENNVDLTINNSRKESSAANSFASVGLFLIFIIAIVLILKSTSKLASKALGFGKNKSKFVTIDDVETRFDDVAGVPEAAEELKEVIKFLNEPKKFTDLGAKVPKGVLLIGPPGTGKTLLAKAIAGESGVPFLSIAASEFVELFVGVGASRVRDLFEKAKEKSPCIIFIDEIDSIGRQRGSGIGGGNDEREQTLNQLLTELDGFADNSGIIVIAATNRPDILDSALLRPGRFDRKIEVMLPDLDGRKKILSVHSLSKPLAKDVDLSYWATRTVGFSGADLANLMNESAIHCAREDSKLITYSHIENALDKVTLGLRTSIISSQNMKKIIAYNEVGRAIVSAVKNGVDSVDKITILPRSGYLGGYTKINPDEDIVSSGLISKKLLLSKIEIALAGRAAEIIVYGKNEITQCSFNDISYATSIIREMVTKYGFSIIGPLSLEDGGEMSIGDGFVRNKSTIADNTYSRIDNEIINISKISLNNAIKIISNNRILLEKLVELLLIKETVENNTFKKITFDLLKV,<ps2>,MRRKIFFEVFNIKKLSILVLGFTLGVIAIWPGIISRNSRKCFFNIIKDGSDGNIQIKTILLVNPNYLLRIKNAKNDYWKVLLVGDACFRKF,<
+<ps1>,MVTSQKKGPDSSASDNELSPDQTLGLVSLSLMQKLSQKDPSFSWLGEMKPDQLNLKNLRDRLELTELAIKTGAPLTTSEVSILMGAKPGKSKIERGGILAIKVARNVWKLSKLGQGSSYYRN,<ps2>,MILKVLEFEFDLIVLGAGSGGLAAAKRAASYGAKVAIIEVNKIGGTCVIRGCVPKKLMVYAANNRRNMLSSEGYGLISKEITFESNILLKNVREEVSRLSVLHSNSLKKLNVKVFEGLGRFLNQNTVEVVCPKTKNILRKVSAKSILISVGGKPKKLNIPGTDFAWTSDDIFELKDFPKKLLIVGGGYIACEFASIFKNLGTEVTQLIRGENLLNGFDKDLSECLEKSMTSLGINLKFKNQLKSIKKINDGLESTLESGSKLLTDNILVATGREPSLKRLNLDTLNLKMDGIYLEVNELNKTSISNIFAIGDIVKRPNLTPVAIEQGRVFADNYFAALKRKVNYENIPKAVFTIPEISTVGLSEEKANEIYSEVNVQVFKCNFTPMSNTFKKNKSKCMLKLVVNKKNDKVLGCHMFGEAASEIIQMVAVSLNTGITKKDFDTTMALHPTISEEFVTMYG,<
+<ps1>,MFFLSIPQAWHLAGTWSEQLPNDSNLIGMSQTELMMTLHSIFVPLLLVISYFLFLKISKNESKKVKG,<ps2>,MTSTLPNDNIKNIDEKISNKLISEIIRDRIKSKGTRFSANDNIADFINPGELKVLEKEVASRIKDLLKSLVIDVDNDHNTQETAERVSKMYLNEVFKGRYHEQPKVTSFPNDKNLDEIYTVGPITVRSACSHHLVPILGECWIGIKPGSKVIGLSKFARVADWVFSRPHIQEEAVMILADEIEKLCEPKGLGIIVKAQHYCMKWRGVKEPNTSMINSVVRGDFRHDISLKQEFFELVRQQSSNNNY,<

README.md

@@ -0,0 +1,195 @@
+---
+license: mit
+library_name: pytorch
+tags:
+  - protein-protein-interaction
+  - ppi
+  - protein-language-model
+  - gpt-2
+  - nanogpt
+  - character-level
+  - trained-from-scratch
+  - bioinformatics
+  - biology
+pipeline_tag: text-generation
+---
+
+# ppiGPLM
+
+A GPT-2 small protein language model trained from scratch on protein-pair prompts and used for binary protein-protein interaction (PPI) classification via next-token prediction. The implementation is based on [nanoGPT](https://github.com/karpathy/nanoGPT) by Andrej Karpathy, with character-level tokenization over amino acids.
+
+![ppiGPLM](assets/ppiGPLM.png)
+
+## Overview
+
+ppiGPLM uses a GPT-2 small architecture (12 layers, 12 attention heads, 768 embedding dimensions) with character-level tokenization to predict whether two proteins interact. Rather than using a separate classification head, ppiGPLM frames PPI prediction as next-token prediction: given a structured prompt encoding a protein pair, the model predicts a binary label (`0` or `1`) as the next token. Softmax probabilities over the label tokens provide continuous interaction scores.
+
+The model was developed for the *Prochlorococcus marinus* MED4 interactome, where it serves as one component of a tri-model consensus framework for computational PPI screening.
+
+## Architecture
+
+| Parameter | Value |
+|-----------|-------|
+| Architecture | GPT-2 small |
+| Layers | 12 |
+| Attention heads | 12 |
+| Embedding dimension | 768 |
+| Context length | 4,096 tokens |
+| Tokenization | Character-level (one token per amino acid) |
+| Dropout | 0.2 |
+| Optimizer | AdamW (lr = 5e-4, beta2 = 0.99) |
+| Training iterations | 8,000 |
+
+## Installation
+
+### Prerequisites
+
+- Python 3.8+
+- CUDA-capable GPU (recommended) or CPU
+- conda (recommended) or pip
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/kouroshSA/ppiGPLM.git
+cd ppiGPLM
+
+# Create a conda environment
+conda create -n gpt python=3.10
+conda activate gpt
+pip install -r requirements.txt
+```
+
+## Repository Structure
+
+```
+ppiGPLM/
+|-- model.py                          # GPT model definition
+|-- train_.py                         # Training loop
+|-- sample_fasta3.3_softmax_error_handling3e.py  # Batch inference script
+|-- LES-wrapper.py                    # Learning Efficiency Score evaluation wrapper
+|-- LES-wrapper.md                    # LES-wrapper documentation
+|-- roc_analysis_color_threshold_F1e.py  # ROC curve analysis
+|-- configurator.py                   # Configuration utility
+|-- config/
+|   |-- train_par_gpt2-s_scratch.py   # Training config (GPT-2 small, from scratch)
+|   +-- finetune_label3.py            # Fine-tuning config
+|-- data/
+|   +-- MED4_char/                    # MED4 PPI dataset
+|       |-- prepare.py                # Character-level tokenizer
+|       +-- meta.pkl                  # Vocabulary (stoi/itos mappings)
+|-- assets/
+|   |-- ppiGPLM.png                  # ASCII workflow diagram
+|   |-- tri_model_consensus.svg      # Tri-model consensus framework (SVG)
+|   +-- tri_model_consensus.png      # Tri-model consensus framework (PNG)
+|-- requirements.txt
+|-- LICENSE
++-- README.md
+```
+
+## Usage
+
+### Prompt Format
+
+Each prompt encodes a protein pair with metadata tags:
+
+```
+<ps1>,MSEQ1...,<ps2>,MSEQ2...,<l1>,len1,<l2>,len2,<l3>
+```
+
+- `<ps1>`, `<ps2>`: Protein sequence delimiters
+- `<l1>`, `<l2>`, `<l3>`: Length field delimiters
+- The model predicts `1` (interacting) or `0` (non-interacting) as the next token
+
+### Batch Inference
+
+Run inference on a set of protein pairs:
+
+```bash
+python sample_fasta3.3_softmax_error_handling3e.py \
+    --input_file protein_pairs.txt \
+    --output_dir ppi_results \
+    --output_prefix my_predictions
+```
+
+This produces:
+- `*_classifications.txt`: Full model output in FASTA-like format
+- `*_probabilities.csv`: Per-pair probabilities for class 1 and class 0
+
+### Training
+
+#### Prepare data
+
+```bash
+python data/MED4_char/prepare.py
+```
+
+This creates `train.bin`, `val.bin`, and `meta.pkl` from the input training data.
+
+#### Train the model
+
+```bash
+# Single GPU
+python train_.py config/train_par_gpt2-s_scratch.py
+
+# Multi-GPU (2 GPUs)
+torchrun --standalone --nproc_per_node=2 train_.py config/train_par_gpt2-s_scratch.py
+```
+
+### Learning Efficiency Score (LES) Evaluation
+
+The LES-wrapper automates evaluation across multiple training checkpoints, computing ROC-AUC, F1, and optimal threshold at each checkpoint and deriving integrated Learning Efficiency Scores:
+
+```bash
+python LES-wrapper.py \
+    --checkpoint_dir out \
+    --prs_file PRS.txt \
+    --rrs_file RRS.txt \
+    --output_dir LES_results \
+    --vanilla
+```
+
+See [LES-wrapper.md](LES-wrapper.md) for full documentation.
+
+### Standalone ROC Analysis
+
+```bash
+python roc_analysis_color_threshold_F1e.py \
+    --prs_file ppi_results/PRS_probabilities.csv \
+    --rrs_file ppi_results/RRS_probabilities.csv
+```
+
+## Architecture Diagrams
+
+The ASCII workflow diagram (`assets/ppiGPLM.png`) covers:
+- **A.** Prompt-based input strategy (character-level tokenization)
+- **B.** Model architecture (GPT-2 small, causal self-attention)
+- **C.** Training pipeline
+- **D.** Inference pipeline with LES evaluation
+
+> Note: the diagram lists "Flash Attention" — this path is taken automatically
+> when running on PyTorch ≥ 2.0; older versions fall back to the manual
+> scaled-dot-product implementation. Numerical results are equivalent.
+
+See `assets/tri_model_consensus.svg` for the tri-model consensus framework with [ppiDCE](https://github.com/kouroshSA/ppiDCE) and [ppiBTEP](https://github.com/kouroshSA/ppiBTEP).
+
+## Citation
+
+If you use this software, please cite:
+
+```
+Daakour, S. et al. (2026).
+```
+
+This software is built on nanoGPT:
+
+```
+Karpathy, A. (2022). nanoGPT. https://github.com/karpathy/nanoGPT
+```
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.
+
+The original nanoGPT framework is by Andrej Karpathy (MIT License, 2022). Modifications and additions for protein-protein interaction prediction are by Kourosh Salehi-Ashtiani (MIT License, 2026).

assets/MANUSCRIPT_NUMBERS_TO_VERIFY.md

@@ -0,0 +1,7 @@
+# Numbers in tri_model_consensus.svg that must match the manuscript
+
+- "~15,000 protein pairs" (input cohort: low-confidence Y2H interactions)
+- "P >= 0.95" (per-model consensus threshold)
+- "657 Tri-Model-Supported Interactions" (intersection output)
+
+If these change in the manuscript, update the SVG and re-render the PNG.

checkpoints/ppiGPLM_ckpt_7e.md

@@ -0,0 +1,30 @@
+# ppiGPLM_ckpt_7e.pt
+
+**Checkpoint used for screening low-confidence Y2H pairs in the *Prochlorococcus marinus* MED4 interactome.**
+
+## Provenance
+
+| | |
+|---|---|
+| Model | ppiGPLM (GPT-2 small, character-level tokenization, trained from scratch on protein-pair prompts) |
+| Architecture | 12 layers, 12 attention heads, 768 emb dim, 4,096 token context |
+| File size | ~1009 MB |
+| Training run | `out_7e` — epoch 70.94 (≈ epoch 71) |
+| Training data | MED4 PPI dataset (`data/MED4_char/`) — prepared by `data/MED4_char/prepare.py` from the project's input CSV/TXT |
+| Tokenization | Per-amino-acid characters (one token per residue), prompts wrapped with `<ps1>`, `<ps2>`, `<l1>`, `<l2>`, `<l3>` delimiter tokens |
+
+## Intended use
+
+Inference / screening of candidate MED4 protein–protein interactions that
+were originally flagged as **low-confidence Y2H hits**. The model is prompted
+with `<ps1>,Seq_A,<ps2>,Seq_B,<l1>,len_A,<l2>,len_B,<l3>` and the next-token
+softmax over `0` / `1` is used (alongside the other tri-model components,
+[ppiBTEP](https://huggingface.co/kouroshSA/ppiBTEP) and
+[ppiDCE](https://huggingface.co/kouroshSA/ppiDCE)) to retain or discard the
+pair.
+
+## Loading
+
+Use `sample_fasta3.3_softmax_error_handling3e.py` from the parent repo, or
+load the checkpoint directly with `train_.py` / `model.py`. The vocabulary
+(`stoi` / `itos` mappings) is read from `data/MED4_char/meta.pkl`.

checkpoints/ppiGPLM_ckpt_7e.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f909843f84f1be924fa411de7b50246b408ded09795b45940e34534a29b46e5
+size 1057547653

config/finetune_label3.py

@@ -0,0 +1,29 @@
+import time
+
+out_dir = 'out-FT'
+eval_interval = 50
+eval_iters = 10
+wandb_log = False # feel free to turn on
+wandb_project = 'Classification4'
+wandb_run_name = 'algaGPT2-S_set4x2_resume'
+
+dataset = 'MED4_char'
+init_from = 'resume' # this is the largest GPT-2 model
+
+# only save checkpoints if the validation loss improves
+
+always_save_checkpoint = False
+
+# the number of examples per iter:
+# 10 batch_size * 1 grad_accum * 1024 tokens = 10240 tokens/iter
+# has xx tokens, so 1 epoch ~= xx iters
+batch_size = 48
+gradient_accumulation_steps = 2
+max_iters = 2000000
+
+# finetune at constant LR
+learning_rate = 1e-5
+decay_lr = False
+
+# To resume training (1GPU) a ckpt in 'shakespear-out' run this 'python train_gpt2-S_resume.py config/finetune_label3.py'
+# To resume training GPT2-M or -S on 2 GPUs: torchrun --standalone --nproc_per_node=2 train_.py config/finetune_label3.py

config/train_par_gpt2-s_scratch.py

@@ -0,0 +1,49 @@
+# Training config: GPT-2 small (124M) from scratch on character-level protein-pair prompts (MED4 PPI).
+
+out_dir = 'out_14e'
+eval_interval = 250 # keep frequent because we'll overfit
+log_interval = 10 # don't print too too often
+
+# we expect to overfit on this small dataset, so only save when val improves
+always_save_checkpoint = True
+
+wandb_log = True
+# override via command line if you like
+wandb_project = 'ppiGLM_MED4Solo'
+wandb_run_name = 'ppiGPLM-med4_4k_14epoch'
+dataset = 'med4_4k_14epoch'
+init_from = 'scratch'  # train from random init; no pretrained GPT-2 weights loaded
+gradient_accumulation_steps = 2
+batch_size = 12
+
+block_size = 4096 # context of up to n previous characters
+
+
+# GPT2-M models
+n_layer = 12
+n_head = 12
+n_embd = 768
+dropout = 0.2
+
+# using above parameters, gradient = 10, batch = 16, token/iter = 98304, epoch = 97600
+
+
+learning_rate = 5e-4 # with baby networks can afford to go a bit higher
+max_iters = 8001
+lr_decay_iters = 8000 # make equal to max_iters usually
+min_lr = 1e-5 # learning_rate / 10 usually
+beta2 = 0.99 # make a bit bigger because number of tokens per iter is small
+
+warmup_iters = 200 # not super necessary potentially
+
+# on macbook also add
+# device = 'cpu'  # run on cpu only
+# compile = False # do not torch compile the model
+
+# To tokenize the training data:  python data/MED4_char/prepare.py
+#
+# To train GPT-2 small from scratch on a single GPU:
+#   python train_.py config/train_par_gpt2-s_scratch.py
+#
+# To train on 2 GPUs with DDP:
+#   torchrun --standalone --nproc_per_node=2 train_.py config/train_par_gpt2-s_scratch.py

configurator.py

@@ -0,0 +1,47 @@
+"""
+Poor Man's Configurator. Probably a terrible idea. Example usage:
+$ python train.py config/override_file.py --batch_size=32
+this will first run config/override_file.py, then override batch_size to 32
+
+The code in this file will be run as follows from e.g. train.py:
+>>> exec(open('configurator.py').read())
+
+So it's not a Python module, it's just shuttling this code away from train.py
+The code in this script then overrides the globals()
+
+I know people are not going to love this, I just really dislike configuration
+complexity and having to prepend config. to every single variable. If someone
+comes up with a better simple Python solution I am all ears.
+"""
+
+import sys
+from ast import literal_eval
+
+for arg in sys.argv[1:]:
+    if '=' not in arg:
+        # assume it's the name of a config file
+        assert not arg.startswith('--')
+        config_file = arg
+        print(f"Overriding config with {config_file}:")
+        with open(config_file) as f:
+            print(f.read())
+        exec(open(config_file).read())
+    else:
+        # assume it's a --key=value argument
+        assert arg.startswith('--')
+        key, val = arg.split('=')
+        key = key[2:]
+        if key in globals():
+            try:
+                # attempt to eval it it (e.g. if bool, number, or etc)
+                attempt = literal_eval(val)
+            except (SyntaxError, ValueError):
+                # if that goes wrong, just use the string
+                attempt = val
+            # ensure the types match ok
+            assert type(attempt) == type(globals()[key])
+            # cross fingers
+            print(f"Overriding: {key} = {attempt}")
+            globals()[key] = attempt
+        else:
+            raise ValueError(f"Unknown config key: {key}")

data/MED4_char/meta.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:983cb09bbc0138f093476ba5db6ec8acaefb7e45211a1194560f7c2abbf4c93c
+size 343

data/MED4_char/prepare.py

@@ -0,0 +1,68 @@
+"""
+Prepare the Shakespeare dataset for character-level language modeling.
+So instead of encoding with GPT-2 BPE tokens, we just map characters to ints.
+Will save train.bin, val.bin containing the ids, and meta.pkl containing the
+encoder and decoder and some other related info.
+"""
+import os
+import pickle
+import requests
+import numpy as np
+
+# download the tiny shakespeare dataset
+input_file_path = os.path.join(os.path.dirname(__file__), 'input.txt')
+if not os.path.exists(input_file_path):
+    data_url = 'https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt'
+    with open(input_file_path, 'w') as f:
+        f.write(requests.get(data_url).text)
+
+with open(input_file_path, 'r') as f:
+    data = f.read()
+print(f"length of dataset in characters: {len(data):,}")
+
+# get all the unique characters that occur in this text
+chars = sorted(list(set(data)))
+vocab_size = len(chars)
+print("all the unique characters:", ''.join(chars))
+print(f"vocab size: {vocab_size:,}")
+
+# create a mapping from characters to integers
+stoi = { ch:i for i,ch in enumerate(chars) }
+itos = { i:ch for i,ch in enumerate(chars) }
+def encode(s):
+    return [stoi[c] for c in s] # encoder: take a string, output a list of integers
+def decode(l):
+    return ''.join([itos[i] for i in l]) # decoder: take a list of integers, output a string
+
+# create the train and test splits
+n = len(data)
+train_data = data[:int(n*0.9)]
+val_data = data[int(n*0.9):]
+
+# encode both to integers
+train_ids = encode(train_data)
+val_ids = encode(val_data)
+print(f"train has {len(train_ids):,} tokens")
+print(f"val has {len(val_ids):,} tokens")
+
+# export to bin files
+train_ids = np.array(train_ids, dtype=np.uint16)
+val_ids = np.array(val_ids, dtype=np.uint16)
+train_ids.tofile(os.path.join(os.path.dirname(__file__), 'train.bin'))
+val_ids.tofile(os.path.join(os.path.dirname(__file__), 'val.bin'))
+
+# save the meta information as well, to help us encode/decode later
+meta = {
+    'vocab_size': vocab_size,
+    'itos': itos,
+    'stoi': stoi,
+}
+with open(os.path.join(os.path.dirname(__file__), 'meta.pkl'), 'wb') as f:
+    pickle.dump(meta, f)
+
+# length of dataset in characters:  1115394
+# all the unique characters:
+#  !$&',-.3:;?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+# vocab size: 65
+# train has 1003854 tokens
+# val has 111540 tokens

data/MED4_char/readme.md

@@ -0,0 +1,15 @@
+
+# character-level
+
+
+(gpt) ksa@ksa-Z790-UD-AC-1:~/Desktop/ppiGPT_MED4_solo/data/shakespeare_char$ python prepare.py
+
+length of dataset in characters: 6,159,128
+all the unique characters:
+,012<>ACDEFGHIKLMNPQRSTVWYps
+vocab size: 29
+train has 5,543,215 tokens
+val has 615,913 tokens
+
+
+epoch =  460,619,820 / 98304 = 4686 it

model.py

@@ -0,0 +1,330 @@
+"""
+Full definition of a GPT Language Model, all of it in this single file.
+References:
+1) the official GPT-2 TensorFlow implementation released by OpenAI:
+https://github.com/openai/gpt-2/blob/master/src/model.py
+2) huggingface/transformers PyTorch implementation:
+https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py
+"""
+
+import math
+import inspect
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+class LayerNorm(nn.Module):
+    """ LayerNorm but with an optional bias. PyTorch doesn't support simply bias=False """
+
+    def __init__(self, ndim, bias):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(ndim))
+        self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None
+
+    def forward(self, input):
+        return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5)
+
+class CausalSelfAttention(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        # key, query, value projections for all heads, but in a batch
+        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias)
+        # output projection
+        self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias)
+        # regularization
+        self.attn_dropout = nn.Dropout(config.dropout)
+        self.resid_dropout = nn.Dropout(config.dropout)
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.dropout = config.dropout
+        # flash attention make GPU go brrrrr but support is only in PyTorch >= 2.0
+        self.flash = hasattr(torch.nn.functional, 'scaled_dot_product_attention')
+        if not self.flash:
+            print("WARNING: using slow attention. Flash Attention requires PyTorch >= 2.0")
+            # causal mask to ensure that attention is only applied to the left in the input sequence
+            self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size))
+                                        .view(1, 1, config.block_size, config.block_size))
+
+    def forward(self, x):
+        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)
+
+        # calculate query, key, values for all heads in batch and move head forward to be the batch dim
+        q, k, v  = self.c_attn(x).split(self.n_embd, dim=2)
+        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
+
+        # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)
+        if self.flash:
+            # efficient attention using Flash Attention CUDA kernels
+            y = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=self.dropout if self.training else 0, is_causal=True)
+        else:
+            # manual implementation of attention
+            att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
+            att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))
+            att = F.softmax(att, dim=-1)
+            att = self.attn_dropout(att)
+            y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
+        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
+
+        # output projection
+        y = self.resid_dropout(self.c_proj(y))
+        return y
+
+class MLP(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.c_fc    = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias)
+        self.gelu    = nn.GELU()
+        self.c_proj  = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias)
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, x):
+        x = self.c_fc(x)
+        x = self.gelu(x)
+        x = self.c_proj(x)
+        x = self.dropout(x)
+        return x
+
+class Block(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        self.ln_1 = LayerNorm(config.n_embd, bias=config.bias)
+        self.attn = CausalSelfAttention(config)
+        self.ln_2 = LayerNorm(config.n_embd, bias=config.bias)
+        self.mlp = MLP(config)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln_1(x))
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+@dataclass
+class GPTConfig:
+    block_size: int = 1024
+    vocab_size: int = 50304 # GPT-2 vocab_size of 50257, padded up to nearest multiple of 64 for efficiency
+    n_layer: int = 12
+    n_head: int = 12
+    n_embd: int = 768
+    dropout: float = 0.0
+    bias: bool = True # True: bias in Linears and LayerNorms, like GPT-2. False: a bit better and faster
+
+class GPT(nn.Module):
+
+    def __init__(self, config):
+        super().__init__()
+        assert config.vocab_size is not None
+        assert config.block_size is not None
+        self.config = config
+
+        self.transformer = nn.ModuleDict(dict(
+            wte = nn.Embedding(config.vocab_size, config.n_embd),
+            wpe = nn.Embedding(config.block_size, config.n_embd),
+            drop = nn.Dropout(config.dropout),
+            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),
+            ln_f = LayerNorm(config.n_embd, bias=config.bias),
+        ))
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        # with weight tying when using torch.compile() some warnings get generated:
+        # "UserWarning: functional_call was passed multiple values for tied weights.
+        # This behavior is deprecated and will be an error in future versions"
+        # not 100% sure what this is, so far seems to be harmless. TODO investigate
+        self.transformer.wte.weight = self.lm_head.weight # https://paperswithcode.com/method/weight-tying
+
+        # init all weights
+        self.apply(self._init_weights)
+        # apply special scaled init to the residual projections, per GPT-2 paper
+        for pn, p in self.named_parameters():
+            if pn.endswith('c_proj.weight'):
+                torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer))
+
+        # report number of parameters
+        print("number of parameters: %.2fM" % (self.get_num_params()/1e6,))
+
+    def get_num_params(self, non_embedding=True):
+        """
+        Return the number of parameters in the model.
+        For non-embedding count (default), the position embeddings get subtracted.
+        The token embeddings would too, except due to the parameter sharing these
+        params are actually used as weights in the final layer, so we include them.
+        """
+        n_params = sum(p.numel() for p in self.parameters())
+        if non_embedding:
+            n_params -= self.transformer.wpe.weight.numel()
+        return n_params
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def forward(self, idx, targets=None):
+        device = idx.device
+        b, t = idx.size()
+        assert t <= self.config.block_size, f"Cannot forward sequence of length {t}, block size is only {self.config.block_size}"
+        pos = torch.arange(0, t, dtype=torch.long, device=device) # shape (t)
+
+        # forward the GPT model itself
+        tok_emb = self.transformer.wte(idx) # token embeddings of shape (b, t, n_embd)
+        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (t, n_embd)
+        x = self.transformer.drop(tok_emb + pos_emb)
+        for block in self.transformer.h:
+            x = block(x)
+        x = self.transformer.ln_f(x)
+
+        if targets is not None:
+            # if we are given some desired targets also calculate the loss
+            logits = self.lm_head(x)
+            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)
+        else:
+            # inference-time mini-optimization: only forward the lm_head on the very last position
+            logits = self.lm_head(x[:, [-1], :]) # note: using list [-1] to preserve the time dim
+            loss = None
+
+        return logits, loss
+
+    def crop_block_size(self, block_size):
+        # model surgery to decrease the block size if necessary
+        # e.g. we may load the GPT2 pretrained model checkpoint (block size 1024)
+        # but want to use a smaller block size for some smaller, simpler model
+        assert block_size <= self.config.block_size
+        self.config.block_size = block_size
+        self.transformer.wpe.weight = nn.Parameter(self.transformer.wpe.weight[:block_size])
+        for block in self.transformer.h:
+            if hasattr(block.attn, 'bias'):
+                block.attn.bias = block.attn.bias[:,:,:block_size,:block_size]
+
+    @classmethod
+    def from_pretrained(cls, model_type, override_args=None):
+        assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}
+        override_args = override_args or {} # default to empty dict
+        # only dropout can be overridden see more notes below
+        assert all(k == 'dropout' for k in override_args)
+        from transformers import GPT2LMHeadModel
+        print("loading weights from pretrained gpt: %s" % model_type)
+
+        # n_layer, n_head and n_embd are determined from model_type
+        config_args = {
+            'gpt2':         dict(n_layer=12, n_head=12, n_embd=768),  # 124M params
+            'gpt2-medium':  dict(n_layer=24, n_head=16, n_embd=1024), # 350M params
+            'gpt2-large':   dict(n_layer=36, n_head=20, n_embd=1280), # 774M params
+            'gpt2-xl':      dict(n_layer=48, n_head=25, n_embd=1600), # 1558M params
+        }[model_type]
+        print("forcing vocab_size=50257, block_size=1024, bias=True")
+        config_args['vocab_size'] = 50257 # always 50257 for GPT model checkpoints
+        config_args['block_size'] = 1024 # always 1024 for GPT model checkpoints
+        config_args['bias'] = True # always True for GPT model checkpoints
+        # we can override the dropout rate, if desired
+        if 'dropout' in override_args:
+            print(f"overriding dropout rate to {override_args['dropout']}")
+            config_args['dropout'] = override_args['dropout']
+        # create a from-scratch initialized minGPT model
+        config = GPTConfig(**config_args)
+        model = GPT(config)
+        sd = model.state_dict()
+        sd_keys = sd.keys()
+        sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] # discard this mask / buffer, not a param
+
+        # init a huggingface/transformers model
+        model_hf = GPT2LMHeadModel.from_pretrained(model_type)
+        sd_hf = model_hf.state_dict()
+
+        # copy while ensuring all of the parameters are aligned and match in names and shapes
+        sd_keys_hf = sd_hf.keys()
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] # ignore these, just a buffer
+        sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] # same, just the mask (buffer)
+        transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight']
+        # basically the openai checkpoints use a "Conv1D" module, but we only want to use a vanilla Linear
+        # this means that we have to transpose these weights when we import them
+        assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}"
+        for k in sd_keys_hf:
+            if any(k.endswith(w) for w in transposed):
+                # special treatment for the Conv1D weights we need to transpose
+                assert sd_hf[k].shape[::-1] == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k].t())
+            else:
+                # vanilla copy over the other parameters
+                assert sd_hf[k].shape == sd[k].shape
+                with torch.no_grad():
+                    sd[k].copy_(sd_hf[k])
+
+        return model
+
+    def configure_optimizers(self, weight_decay, learning_rate, betas, device_type):
+        # start with all of the candidate parameters
+        param_dict = {pn: p for pn, p in self.named_parameters()}
+        # filter out those that do not require grad
+        param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad}
+        # create optim groups. Any parameters that is 2D will be weight decayed, otherwise no.
+        # i.e. all weight tensors in matmuls + embeddings decay, all biases and layernorms don't.
+        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]
+        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]
+        optim_groups = [
+            {'params': decay_params, 'weight_decay': weight_decay},
+            {'params': nodecay_params, 'weight_decay': 0.0}
+        ]
+        num_decay_params = sum(p.numel() for p in decay_params)
+        num_nodecay_params = sum(p.numel() for p in nodecay_params)
+        print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters")
+        print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters")
+        # Create AdamW optimizer and use the fused version if it is available
+        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters
+        use_fused = fused_available and device_type == 'cuda'
+        extra_args = dict(fused=True) if use_fused else dict()
+        optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args)
+        print(f"using fused AdamW: {use_fused}")
+
+        return optimizer
+
+    def estimate_mfu(self, fwdbwd_per_iter, dt):
+        """ estimate model flops utilization (MFU) in units of A100 bfloat16 peak FLOPS """
+        # first estimate the number of flops we do per iteration.
+        # see PaLM paper Appendix B as ref: https://arxiv.org/abs/2204.02311
+        N = self.get_num_params()
+        cfg = self.config
+        L, H, Q, T = cfg.n_layer, cfg.n_head, cfg.n_embd//cfg.n_head, cfg.block_size
+        flops_per_token = 6*N + 12*L*H*Q*T
+        flops_per_fwdbwd = flops_per_token * T
+        flops_per_iter = flops_per_fwdbwd * fwdbwd_per_iter
+        # express our flops throughput as ratio of A100 bfloat16 peak flops
+        flops_achieved = flops_per_iter * (1.0/dt) # per second
+        flops_promised = 312e12 # A100 GPU bfloat16 peak flops is 312 TFLOPS
+        mfu = flops_achieved / flops_promised
+        return mfu
+
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
+        """
+        Take a conditioning sequence of indices idx (LongTensor of shape (b,t)) and complete
+        the sequence max_new_tokens times, feeding the predictions back into the model each time.
+        Most likely you'll want to make sure to be in model.eval() mode of operation for this.
+        """
+        for _ in range(max_new_tokens):
+            # if the sequence context is growing too long we must crop it at block_size
+            idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]
+            # forward the model to get the logits for the index in the sequence
+            logits, _ = self(idx_cond)
+            # pluck the logits at the final step and scale by desired temperature
+            logits = logits[:, -1, :] / temperature
+            # optionally crop the logits to only the top k options
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            # apply softmax to convert logits to (normalized) probabilities
+            probs = F.softmax(logits, dim=-1)
+            # sample from the distribution
+            idx_next = torch.multinomial(probs, num_samples=1)
+            # append sampled index to the running sequence and continue
+            idx = torch.cat((idx, idx_next), dim=1)
+
+        return idx

requirements.txt

@@ -0,0 +1,7 @@
+# Optional: wandb is only imported when wandb_log=True is set in the training config.
+torch>=2.0
+numpy
+tqdm
+wandb
+scikit-learn
+matplotlib

roc_analysis_color_threshold_F1e.py

@@ -0,0 +1,210 @@
+"""
+
+Notes:
+
+The script handles variable numbers of PRS and RRS probability values.
+It combines the probabilities and labels, computes the ROC curve, calculates the AUC (Area Under the Curve), and plots the ROC curve using Matplotlib.
+You can customize the script to read multiple PRS and RRS files by modifying the read_probabilities function and how you handle the input arguments.
+Dependencies:
+
+Python 3
+numpy
+matplotlib
+scikit-learn
+
+Explanation of the Area Under the Curve (AUC):
+
+The Area Under the Curve (AUC) refers to the area under the Receiver Operating Characteristic (ROC) curve. The ROC curve is a graphical representation of a classifier's performance across all classification thresholds. It plots the True Positive Rate (TPR) against the False Positive Rate (FPR) at various threshold settings.
+
+True Positive Rate (TPR), also known as Sensitivity or Recall, is the proportion of actual positives that are correctly identified.
+False Positive Rate (FPR) is the proportion of actual negatives that are incorrectly identified as positives.
+The AUC provides a single scalar value that summarizes the performance of the classifier:
+
+An AUC of 1.0 indicates a perfect classifier.
+An AUC of 0.5 suggests no discriminative ability (equivalent to random guessing).
+An AUC between 0.5 and 1.0 indicates the degree to which the classifier can distinguish between the positive and negative classes.
+Why is AUC important?
+
+More on interpreting the ROC Curve:
+
+The ROC curve plots the TPR against the FPR at various threshold levels.
+The closer the curve follows the left-hand border and then the top border of the ROC space, the better the classifier.
+The diagonal line represents the performance of a classifier that makes random guesses.
+Understanding AUC Values:
+
+AUC = 0.90-1.00: Excellent
+AUC = 0.80-0.90: Good
+AUC = 0.70-0.80: Fair
+AUC = 0.60-0.70: Poor
+AUC = 0.50-0.60: Fail
+
+
+
+Threshold-Independent: AUC measures the classifier's ability to rank predictions without being dependent on a specific threshold.
+Performance Metric: It provides a comprehensive measure of performance across all possible classification thresholds.
+In summary, the AUC quantifies the overall ability of the model to discriminate between positive and negative classes. A higher AUC indicates better model performance.
+
+
+
+F1 = 2 * ( (precision * recall) / (precision + recall) )
+
+precision = TP / (TP + FP)
+
+recall = TP / (TP + FN)
+
+
+You can adjust the decimal percision by changing ".6f" to desired value in  f'Best F1 Threshold: {best_thresh:.6f}'
+
+
+"""
+#
+
+# pip install numpy matplotlib scikit-learn
+
+# python roc_analysis_color_threshold_F1e.py --input_csv probabilities.csv --output_file roc_curve.png
+
+#!/usr/bin/env python
+
+#!/usr/bin/env python
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_curve, auc, f1_score
+import csv
+
+def read_probabilities_from_csv(filename):
+    """Read PRS and RRS probability values from a CSV file."""
+    prs_probs = []
+    rrs_probs = []
+    with open(filename, 'r') as csvfile:
+        reader = csv.reader(csvfile)
+        headers = next(reader)  # Skip the header row
+        for row in reader:
+            # Ensure there are at least two columns
+            if len(row) >= 2:
+                prs_value = row[0].strip()
+                rrs_value = row[1].strip()
+                # Append PRS probability if not empty
+                if prs_value:
+                    prs_probs.append(float(prs_value))
+                # Append RRS probability if not empty
+                if rrs_value:
+                    rrs_probs.append(float(rrs_value))
+    return prs_probs, rrs_probs
+
+def main():
+    parser = argparse.ArgumentParser(description='Compute ROC curve, best F1 score, and annotate thresholds.')
+    parser.add_argument('--input_csv', required=True, help='CSV file containing PRS and RRS probability values')
+    parser.add_argument('--output_file', default='roc_curve.png', help='Output file name for ROC curve plot')
+
+    args = parser.parse_args()
+
+    # Read probability values from CSV file
+    prs_probs, rrs_probs = read_probabilities_from_csv(args.input_csv)
+
+    # Assign labels
+    prs_labels = [1] * len(prs_probs)
+    rrs_labels = [0] * len(rrs_probs)
+
+    # Combine probabilities and labels
+    probs = np.array(prs_probs + rrs_probs)
+    labels = np.array(prs_labels + rrs_labels)
+
+    # Compute ROC curve and AUC
+    fpr, tpr, thresholds = roc_curve(labels, probs)
+    roc_auc = auc(fpr, tpr)
+
+    # Exclude infinite thresholds and thresholds outside [0, 1]
+    finite_idxs = np.where(np.isfinite(thresholds))[0]
+    fpr = fpr[finite_idxs]
+    tpr = tpr[finite_idxs]
+    thresholds = thresholds[finite_idxs]
+
+    # Filter thresholds within [0, 1]
+    valid_thresholds_idxs = np.where((thresholds >= 0) & (thresholds <= 1))[0]
+    fpr = fpr[valid_thresholds_idxs]
+    tpr = tpr[valid_thresholds_idxs]
+    thresholds = thresholds[valid_thresholds_idxs]
+
+    # Compute best F1 score across thresholds
+    best_f1 = -1.0
+    best_thresh = None
+    best_idx = None
+    for i, thresh in enumerate(thresholds):
+        predicted_labels = (probs >= thresh).astype(int)
+        current_f1 = f1_score(labels, predicted_labels)
+        if current_f1 > best_f1:
+            best_f1 = current_f1
+            best_thresh = thresh
+            best_idx = i
+
+    # Retrieve FPR and TPR for the best threshold
+    best_fpr = fpr[best_idx]
+    best_tpr = tpr[best_idx]
+
+    # Set global font
+    plt.rcParams['font.family'] = 'Arial'
+
+    # Create figure and colormap
+    fig, ax = plt.subplots(figsize=(10, 8))
+    norm = plt.Normalize(vmin=thresholds.min(), vmax=thresholds.max())
+    cmap = plt.cm.viridis
+
+    # Plot the ROC curve in segments, color-coded by threshold
+    for i in range(len(fpr) - 1):
+        x = fpr[i:i + 2]
+        y = tpr[i:i + 2]
+        z = thresholds[i]
+        ax.plot(x, y, color=cmap(norm(z)), lw=2.5)
+
+    # Diagonal line
+    ax.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')
+
+    # Add a colorbar for thresholds
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    sm.set_array([])
+    cbar = fig.colorbar(sm, ax=ax)
+    cbar.set_label('Threshold', fontsize=16)
+    cbar.ax.tick_params(labelsize=14)
+
+    # Annotate a subset of thresholds on the ROC curve
+    num_thresholds_to_annotate = 10  # Number of thresholds to annotate
+    idxs = np.linspace(0, len(thresholds) - 1, num_thresholds_to_annotate).astype(int)
+    for idx in idxs:
+        thresh = thresholds[idx]
+        ax.annotate(f'{thresh:.2f}', xy=(fpr[idx], tpr[idx]),
+                     textcoords='offset points', xytext=(0, 10),
+                     ha='center', fontsize=12, color='blue')
+
+    # No red scatter point for the best threshold
+    # ax.scatter(best_fpr, best_tpr, color='red', s=100, zorder=5)
+
+    # Set axis limits and labels
+    ax.set_xlim([0.0, 1.0])
+    ax.set_ylim([0.0, 1.05])
+    ax.set_xlabel('False Positive Rate', fontsize=16)
+    ax.set_ylabel('True Positive Rate', fontsize=16)
+    ax.set_title('Receiver Operating Characteristic (ROC)', fontsize=18)
+    ax.tick_params(axis='both', which='major', labelsize=14)
+
+    # Add gridlines
+    ax.grid(True, linestyle='--', linewidth=0.5, alpha=0.7)
+
+    # Add legend with 3 decimal places
+    legend_text = (f'ROC curve (AUC = {roc_auc:.3f}, '
+                   f'Best F1 = {best_f1:.3f}, '
+                   f'Best F1 Threshold = {best_thresh:.3f})')
+    ax.legend([legend_text], loc="lower right", fontsize=12)
+
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save and show the figure
+    plt.savefig(args.output_file, dpi=300, format='png')
+    plt.show()
+
+    print(f"ROC curve saved to {args.output_file}")
+    print(f"Best F1 Score: {best_f1:.3f} at threshold {best_thresh:.3f}")
+
+if __name__ == '__main__':
+    main()

sample_fasta3.3_softmax_error_handling3e.py

@@ -0,0 +1,164 @@
+"""
+sample_fasta3.3_softmax_error_handling3e.py — batch inference for ppiGPLM.
+
+Loads a ckpt.pt from <model_dir> (default "out") and runs inference on a file of
+prompts (one prompt per line, no quotes), producing:
+
+  - <output_prefix>_classifications.txt : FASTA-like dump of model output
+  - <output_prefix>_probabilities.csv   : per-pair softmax probabilities for "1" and "0"
+
+Robustness:
+  - Block-size detection from checkpoint[‘model_args’][‘block_size’] (or
+    model.config.n_positions for GPT-2 variants).
+  - Input clipping: if a prompt exceeds block_size, the head is clipped
+    (start_ids = start_ids[-block_size:]) so the label position stays intact.
+  - Unknown-token replacement: out-of-vocab characters are mapped to ‘A’.
+
+Usage:
+    python sample_fasta3.3_softmax_error_handling3e.py \\
+        --input_file my_prompts.txt \\
+        --output_dir results \\
+        --output_prefix myoutput
+"""
+
+import os
+import sys
+import argparse
+from contextlib import nullcontext
+import pickle
+import torch
+import torch.nn.functional as F
+from model import GPTConfig, GPT
+
+# -----------------------------------------------------------------------------
+# Parse command-line arguments
+# -----------------------------------------------------------------------------
+parser = argparse.ArgumentParser(description='Sample from a trained model with prompt input.')
+parser.add_argument('--input_file', type=str, default='generated_prompts.txt', help='Path to file containing prompts')
+parser.add_argument('--output_dir', type=str, default='out-ppi', help='Directory to save outputs')
+parser.add_argument('--output_prefix', type=str, default='generated', help='Prefix for output files')
+args = parser.parse_args()
+
+# Reset sys.argv for configurator
+sys.argv = [sys.argv[0]]
+
+prompts_file_path = args.input_file
+output_dir = args.output_dir
+os.makedirs(output_dir, exist_ok=True)
+
+fasta_output_filename = os.path.join(output_dir, args.output_prefix + '_classifications.txt')
+csv_output_filename = os.path.join(output_dir, args.output_prefix + '_probabilities.csv')
+
+# -----------------------------------------------------------------------------
+# Sampling parameters and model init overrides
+# -----------------------------------------------------------------------------
+init_from = 'resume'  # or a GPT-2 variant
+model_dir = 'out'
+max_new_tokens = 1
+temperature = 0.1
+top_k = 2
+seed = int.from_bytes(os.urandom(4), 'big')
+device = 'cuda'
+dtype = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16'
+compile = False
+exec(open('configurator.py').read())  # overrides from command line or config file
+
+torch.manual_seed(seed)
+torch.cuda.manual_seed(seed)
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+device_type = 'cuda' if 'cuda' in device else 'cpu'
+ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]
+ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+# -----------------------------------------------------------------------------
+# Model Initialization
+# -----------------------------------------------------------------------------
+if init_from == 'resume':
+    ckpt_path = os.path.join(model_dir, 'ckpt.pt')
+    checkpoint = torch.load(ckpt_path, map_location=device)
+    gptconf = GPTConfig(**checkpoint['model_args'])
+    model = GPT(gptconf)
+    state_dict = checkpoint['model']
+    unwanted_prefix = '_orig_mod.'
+    for k in list(state_dict.keys()):
+        if k.startswith(unwanted_prefix):
+            state_dict[k[len(unwanted_prefix):]] = state_dict.pop(k)
+    model.load_state_dict(state_dict)
+    block_size = checkpoint['model_args'].get('block_size', 1024)
+else:
+    model = GPT.from_pretrained(init_from, dict(dropout=0.0))
+    block_size = getattr(model.config, 'n_positions', 1024)
+
+model.eval()
+model.to(device)
+if compile:
+    model = torch.compile(model)
+
+# -----------------------------------------------------------------------------
+# Load vocabulary mapping for character-level tokenization
+# -----------------------------------------------------------------------------
+meta_path = os.path.join('data', checkpoint['config']['dataset'], 'meta.pkl')
+if not os.path.exists(meta_path):
+    raise FileNotFoundError(f'Meta file not found: {meta_path}')
+with open(meta_path, 'rb') as meta_file:
+    meta = pickle.load(meta_file)
+stoi = meta['stoi']
+itos = meta['itos']
+encode = lambda s: [stoi.get(ch, stoi.get('<unk>', 0)) for ch in s]
+decode = lambda l: ''.join([itos.get(i, '') for i in l])
+
+# -----------------------------------------------------------------------------
+# Read prompts
+# -----------------------------------------------------------------------------
+with open(prompts_file_path, 'r', encoding='utf-8') as f:
+    prompts = [line.strip() for line in f if line.strip()]
+
+# -----------------------------------------------------------------------------
+# Token IDs for classification tokens
+# -----------------------------------------------------------------------------
+one_id = encode('1')[0] if encode('1') else None
+zero_id = encode('0')[0] if encode('0') else None
+
+# -----------------------------------------------------------------------------
+# FASTA formatting helper
+# -----------------------------------------------------------------------------
+def format_as_fasta(sequence, sample_number):
+    return f'>Sample_{sample_number}\n{sequence}\n'
+
+# -----------------------------------------------------------------------------
+# Generate outputs and write to files
+# -----------------------------------------------------------------------------
+with open(fasta_output_filename, 'w', encoding='utf-8') as fasta_file, \
+     open(csv_output_filename, 'w', encoding='utf-8') as csv_file:
+    csv_file.write('l1,Seq1,l2,Seq2,l3,Probability_of_1,Probability_of_0\n')
+    with torch.no_grad():
+        with ctx:
+            for k, prompt in enumerate(prompts):
+                start_ids = encode(prompt)
+                if len(start_ids) > block_size:
+                    start_ids = start_ids[-block_size:]
+                x = torch.tensor(start_ids, dtype=torch.long, device=device).unsqueeze(0)
+
+                logits = model(x)
+                if isinstance(logits, tuple):
+                    logits = logits[0]
+                last_logits = logits[:, -1, :]
+                probs = F.softmax(last_logits, dim=-1)
+
+                prob_for_1 = probs[0, one_id].item() if one_id is not None and one_id < probs.shape[-1] else 0.0
+                prob_for_0 = probs[0, zero_id].item() if zero_id is not None and zero_id < probs.shape[-1] else 0.0
+
+                y = model.generate(idx=x, max_new_tokens=max_new_tokens, temperature=temperature, top_k=top_k)
+                sample_text = decode(y[0].tolist())
+
+                fasta_file.write(format_as_fasta(sample_text, k) + '\n')
+                csv_file.write(f'{prompt},{prob_for_1},{prob_for_0}\n')
+
+                print(format_as_fasta(sample_text, k))
+                print(f'Probability(next_token=1) = {prob_for_1}')
+                print(f'Probability(next_token=0) = {prob_for_0}')
+                print('---------------')
+
+print(f'FASTA-like samples saved to {fasta_output_filename}')
+print(f'CSV with probabilities saved to {csv_output_filename}')

train_.py

@@ -0,0 +1,333 @@
+"""
+This training script can be run both on a single gpu in debug mode,
+and also in a larger training run with distributed data parallel (ddp).
+
+To run on a single GPU, example:
+$ python train.py --batch_size=32 --compile=False
+
+To run with DDP on 4 gpus on 1 node, example:
+$ torchrun --standalone --nproc_per_node=4 train.py
+
+To run with DDP on 4 gpus across 2 nodes, example:
+- Run on the first (master) node with example IP 123.456.123.456:
+$ torchrun --nproc_per_node=8 --nnodes=2 --node_rank=0 --master_addr=123.456.123.456 --master_port=1234 train.py
+- Run on the worker node:
+$ torchrun --nproc_per_node=8 --nnodes=2 --node_rank=1 --master_addr=123.456.123.456 --master_port=1234 train.py
+(If your cluster does not have Infiniband interconnect prepend NCCL_IB_DISABLE=1)
+"""
+
+import os
+import time
+import math
+import pickle
+from contextlib import nullcontext
+
+import numpy as np
+import torch
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.distributed import init_process_group, destroy_process_group
+
+from model import GPTConfig, GPT
+
+# -----------------------------------------------------------------------------
+# default config values designed to train a gpt2 (124M) on OpenWebText
+# I/O
+out_dir = 'out'
+eval_interval = 2000
+log_interval = 1
+eval_iters = 200
+eval_only = False # if True, script exits right after the first eval
+always_save_checkpoint = True # if True, always save a checkpoint after each eval
+init_from = 'scratch' # 'scratch' or 'resume' or 'gpt2*'
+# wandb logging
+wandb_log = False # disabled by default
+wandb_project = 'owt'
+wandb_run_name = 'gpt2' # 'run' + str(time.time())
+# data
+dataset = 'openwebtext'
+gradient_accumulation_steps = 5 * 8 # used to simulate larger batch sizes
+batch_size = 12 # if gradient_accumulation_steps > 1, this is the micro-batch size
+block_size = 1024
+# model
+n_layer = 12
+n_head = 12
+n_embd = 768
+dropout = 0.0 # for pretraining 0 is good, for finetuning try 0.1+
+bias = False # do we use bias inside LayerNorm and Linear layers?
+# adamw optimizer
+learning_rate = 6e-4 # max learning rate
+max_iters = 600000 # total number of training iterations
+weight_decay = 1e-1
+beta1 = 0.9
+beta2 = 0.95
+grad_clip = 1.0 # clip gradients at this value, or disable if == 0.0
+# learning rate decay settings
+decay_lr = True # whether to decay the learning rate
+warmup_iters = 2000 # how many steps to warm up for
+lr_decay_iters = 600000 # should be ~= max_iters per Chinchilla
+min_lr = 6e-5 # minimum learning rate, should be ~= learning_rate/10 per Chinchilla
+# DDP settings
+backend = 'nccl' # 'nccl', 'gloo', etc.
+# system
+device = 'cuda' # examples: 'cpu', 'cuda', 'cuda:0', 'cuda:1' etc., or try 'mps' on macbooks
+dtype = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16' # 'float32', 'bfloat16', or 'float16', the latter will auto implement a GradScaler
+compile = True # use PyTorch 2.0 to compile the model to be faster
+# -----------------------------------------------------------------------------
+config_keys = [k for k,v in globals().items() if not k.startswith('_') and isinstance(v, (int, float, bool, str))]
+exec(open('configurator.py').read()) # overrides from command line or config file
+config = {k: globals()[k] for k in config_keys} # will be useful for logging
+# -----------------------------------------------------------------------------
+
+# various inits, derived attributes, I/O setup
+ddp = int(os.environ.get('RANK', -1)) != -1 # is this a ddp run?
+if ddp:
+    init_process_group(backend=backend)
+    ddp_rank = int(os.environ['RANK'])
+    ddp_local_rank = int(os.environ['LOCAL_RANK'])
+    ddp_world_size = int(os.environ['WORLD_SIZE'])
+    device = f'cuda:{ddp_local_rank}'
+    torch.cuda.set_device(device)
+    master_process = ddp_rank == 0 # this process will do logging, checkpointing etc.
+    seed_offset = ddp_rank # each process gets a different seed
+    # world_size number of processes will be training simultaneously, so we can scale
+    # down the desired gradient accumulation iterations per process proportionally
+    assert gradient_accumulation_steps % ddp_world_size == 0
+    gradient_accumulation_steps //= ddp_world_size
+else:
+    # if not ddp, we are running on a single gpu, and one process
+    master_process = True
+    seed_offset = 0
+    ddp_world_size = 1
+tokens_per_iter = gradient_accumulation_steps * ddp_world_size * batch_size * block_size
+print(f"tokens per iteration will be: {tokens_per_iter:,}")
+
+if master_process:
+    os.makedirs(out_dir, exist_ok=True)
+torch.manual_seed(1337 + seed_offset)
+torch.backends.cuda.matmul.allow_tf32 = True # allow tf32 on matmul
+torch.backends.cudnn.allow_tf32 = True # allow tf32 on cudnn
+device_type = 'cuda' if 'cuda' in device else 'cpu' # for later use in torch.autocast
+# note: float16 data type will automatically use a GradScaler
+ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]
+ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+# poor man's data loader
+data_dir = os.path.join('data', dataset)
+train_data = np.memmap(os.path.join(data_dir, 'train.bin'), dtype=np.uint16, mode='r')
+val_data = np.memmap(os.path.join(data_dir, 'val.bin'), dtype=np.uint16, mode='r')
+def get_batch(split):
+    data = train_data if split == 'train' else val_data
+    ix = torch.randint(len(data) - block_size, (batch_size,))
+    x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])
+    y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])
+    if device_type == 'cuda':
+        # pin arrays x,y, which allows us to move them to GPU asynchronously (non_blocking=True)
+        x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)
+    else:
+        x, y = x.to(device), y.to(device)
+    return x, y
+
+# init these up here, can override if init_from='resume' (i.e. from a checkpoint)
+iter_num = 0
+best_val_loss = 1e9
+
+# attempt to derive vocab_size from the dataset
+meta_path = os.path.join(data_dir, 'meta.pkl')
+meta_vocab_size = None
+if os.path.exists(meta_path):
+    with open(meta_path, 'rb') as f:
+        meta = pickle.load(f)
+    meta_vocab_size = meta['vocab_size']
+    print(f"found vocab_size = {meta_vocab_size} (inside {meta_path})")
+
+# model init
+model_args = dict(n_layer=n_layer, n_head=n_head, n_embd=n_embd, block_size=block_size,
+                  bias=bias, vocab_size=None, dropout=dropout) # start with model_args from command line
+if init_from == 'scratch':
+    # init a new model from scratch
+    print("Initializing a new model from scratch")
+    # determine the vocab size we'll use for from-scratch training
+    if meta_vocab_size is None:
+        print("defaulting to vocab_size of GPT-2 to 50304 (50257 rounded up for efficiency)")
+    model_args['vocab_size'] = meta_vocab_size if meta_vocab_size is not None else 50304
+    gptconf = GPTConfig(**model_args)
+    model = GPT(gptconf)
+elif init_from == 'resume':
+    print(f"Resuming training from {out_dir}")
+    # resume training from a checkpoint.
+    ckpt_path = os.path.join(out_dir, 'ckpt.pt')
+    checkpoint = torch.load(ckpt_path, map_location=device)
+    checkpoint_model_args = checkpoint['model_args']
+    # force these config attributes to be equal otherwise we can't even resume training
+    # the rest of the attributes (e.g. dropout) can stay as desired from command line
+    for k in ['n_layer', 'n_head', 'n_embd', 'block_size', 'bias', 'vocab_size']:
+        model_args[k] = checkpoint_model_args[k]
+    # create the model
+    gptconf = GPTConfig(**model_args)
+    model = GPT(gptconf)
+    state_dict = checkpoint['model']
+    # fix the keys of the state dictionary :(
+    # honestly no idea how checkpoints sometimes get this prefix, have to debug more
+    unwanted_prefix = '_orig_mod.'
+    for k,v in list(state_dict.items()):
+        if k.startswith(unwanted_prefix):
+            state_dict[k[len(unwanted_prefix):]] = state_dict.pop(k)
+    model.load_state_dict(state_dict)
+    iter_num = checkpoint['iter_num']
+    best_val_loss = checkpoint['best_val_loss']
+elif init_from.startswith('gpt2'):
+    print(f"Initializing from OpenAI GPT-2 weights: {init_from}")
+    # initialize from OpenAI GPT-2 weights
+    override_args = dict(dropout=dropout)
+    model = GPT.from_pretrained(init_from, override_args)
+    # read off the created config params, so we can store them into checkpoint correctly
+    for k in ['n_layer', 'n_head', 'n_embd', 'block_size', 'bias', 'vocab_size']:
+        model_args[k] = getattr(model.config, k)
+# crop down the model block size if desired, using model surgery
+if block_size < model.config.block_size:
+    model.crop_block_size(block_size)
+    model_args['block_size'] = block_size # so that the checkpoint will have the right value
+model.to(device)
+
+# initialize a GradScaler. If enabled=False scaler is a no-op
+scaler = torch.cuda.amp.GradScaler(enabled=(dtype == 'float16'))
+
+# optimizer
+optimizer = model.configure_optimizers(weight_decay, learning_rate, (beta1, beta2), device_type)
+if init_from == 'resume':
+    optimizer.load_state_dict(checkpoint['optimizer'])
+checkpoint = None # free up memory
+
+# compile the model
+if compile:
+    print("compiling the model... (takes a ~minute)")
+    unoptimized_model = model
+    model = torch.compile(model) # requires PyTorch 2.0
+
+# wrap model into DDP container
+if ddp:
+    model = DDP(model, device_ids=[ddp_local_rank])
+
+# helps estimate an arbitrarily accurate loss over either split using many batches
+@torch.no_grad()
+def estimate_loss():
+    out = {}
+    model.eval()
+    for split in ['train', 'val']:
+        losses = torch.zeros(eval_iters)
+        for k in range(eval_iters):
+            X, Y = get_batch(split)
+            with ctx:
+                logits, loss = model(X, Y)
+            losses[k] = loss.item()
+        out[split] = losses.mean()
+    model.train()
+    return out
+
+# learning rate decay scheduler (cosine with warmup)
+def get_lr(it):
+    # 1) linear warmup for warmup_iters steps
+    if it < warmup_iters:
+        return learning_rate * it / warmup_iters
+    # 2) if it > lr_decay_iters, return min learning rate
+    if it > lr_decay_iters:
+        return min_lr
+    # 3) in between, use cosine decay down to min learning rate
+    decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters)
+    assert 0 <= decay_ratio <= 1
+    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff ranges 0..1
+    return min_lr + coeff * (learning_rate - min_lr)
+
+# logging
+if wandb_log and master_process:
+    import wandb
+    wandb.init(project=wandb_project, name=wandb_run_name, config=config)
+
+# training loop
+X, Y = get_batch('train') # fetch the very first batch
+t0 = time.time()
+local_iter_num = 0 # number of iterations in the lifetime of this process
+raw_model = model.module if ddp else model # unwrap DDP container if needed
+running_mfu = -1.0
+while True:
+
+    # determine and set the learning rate for this iteration
+    lr = get_lr(iter_num) if decay_lr else learning_rate
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+
+    # evaluate the loss on train/val sets and write checkpoints
+    if iter_num % eval_interval == 0 and master_process:
+        losses = estimate_loss()
+        print(f"step {iter_num}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}")
+        if wandb_log:
+            wandb.log({
+                "iter": iter_num,
+                "train/loss": losses['train'],
+                "val/loss": losses['val'],
+                "lr": lr,
+                "mfu": running_mfu*100, # convert to percentage
+            })
+        if losses['val'] < best_val_loss or always_save_checkpoint:
+            best_val_loss = losses['val']
+            if iter_num > 0:
+                checkpoint = {
+                    'model': raw_model.state_dict(),
+                    'optimizer': optimizer.state_dict(),
+                    'model_args': model_args,
+                    'iter_num': iter_num,
+                    'best_val_loss': best_val_loss,
+                    'config': config,
+                }
+                print(f"saving checkpoint to {out_dir}")
+                torch.save(checkpoint, os.path.join(out_dir, 'ckpt.pt'))
+    if iter_num == 0 and eval_only:
+        break
+
+    # forward backward update, with optional gradient accumulation to simulate larger batch size
+    # and using the GradScaler if data type is float16
+    for micro_step in range(gradient_accumulation_steps):
+        if ddp:
+            # in DDP training we only need to sync gradients at the last micro step.
+            # the official way to do this is with model.no_sync() context manager, but
+            # I really dislike that this bloats the code and forces us to repeat code
+            # looking at the source of that context manager, it just toggles this variable
+            model.require_backward_grad_sync = (micro_step == gradient_accumulation_steps - 1)
+        with ctx:
+            logits, loss = model(X, Y)
+            loss = loss / gradient_accumulation_steps # scale the loss to account for gradient accumulation
+        # immediately async prefetch next batch while model is doing the forward pass on the GPU
+        X, Y = get_batch('train')
+        # backward pass, with gradient scaling if training in fp16
+        scaler.scale(loss).backward()
+    # clip the gradient
+    if grad_clip != 0.0:
+        scaler.unscale_(optimizer)
+        torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+    # step the optimizer and scaler if training in fp16
+    scaler.step(optimizer)
+    scaler.update()
+    # flush the gradients as soon as we can, no need for this memory anymore
+    optimizer.zero_grad(set_to_none=True)
+
+    # timing and logging
+    t1 = time.time()
+    dt = t1 - t0
+    t0 = t1
+    if iter_num % log_interval == 0 and master_process:
+        # get loss as float. note: this is a CPU-GPU sync point
+        # scale up to undo the division above, approximating the true total loss (exact would have been a sum)
+        lossf = loss.item() * gradient_accumulation_steps
+        if local_iter_num >= 5: # let the training loop settle a bit
+            mfu = raw_model.estimate_mfu(batch_size * gradient_accumulation_steps, dt)
+            running_mfu = mfu if running_mfu == -1.0 else 0.9*running_mfu + 0.1*mfu
+        print(f"iter {iter_num}: loss {lossf:.4f}, time {dt*1000:.2f}ms, mfu {running_mfu*100:.2f}%")
+    iter_num += 1
+    local_iter_num += 1
+
+    # termination conditions
+    if iter_num > max_iters:
+        break
+
+if ddp:
+    destroy_process_group()