push to main

.gitattributes

@@ -0,0 +1,49 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+pretrain filter=lfs diff=lfs merge=lfs -text
+pretrain/LipNet_overlap_loss_0.07664558291435242_wer_0.04644484056248762_cer_0.019676921477851092.pt filter=lfs diff=lfs merge=lfs -text
+pretrain/LipNet_unseen_loss_0.44562849402427673_wer_0.1332580699113564_cer_0.06796452465503355.pt filter=lfs diff=lfs merge=lfs -text
+demo.gif filter=lfs diff=lfs merge=lfs -text
+lip.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID_aligns.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID_imgs.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID_wavs.zip filter=lfs diff=lfs merge=lfs -text
+pretrain/shape_predictor_68_face_landmarks.dat filter=lfs diff=lfs merge=lfs -text
+lip/GRID_crop_lips.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID_lips.zip filter=lfs diff=lfs merge=lfs -text
+lip/GRID_phonemes.zip filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+runs
+weights
+__pycache__
+GRID_align_txt
+.idea/
+.vscode/
+venv/
+lip/**
+!lip/**.zip
+**/**.jpg
+temp/
+GRID/**
+GRID-dataset/**
+GRID_aligns/**
+GRID_aligns_new/**
+GRID_imgs/**
+GRID_new/**
+GRID_wavs/**
+GRID_wavs_new/**
+.pause

BaseTrainer.py

@@ -0,0 +1,67 @@
+import os
+import numpy as np
+import shutil
+import resource
+import options as opt
+
+from helpers import *
+from datetime import datetime as Datetime
+from tensorboardX import SummaryWriter
+
+rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
+resource.setrlimit(
+    resource.RLIMIT_NOFILE, (65536, rlimit[1])
+)
+
+
+class BaseTrainer(object):
+    def __init__(self, name='M', base_dir=''):
+        self.name = name
+        self.base_dir = base_dir
+
+        self.date_stamp = self.make_date_stamp()
+        self.save_name = f'{self.name}-{self.date_stamp}'
+        self.weights_dir = None
+        self.log_dir = None
+        self.writer = None
+
+    @staticmethod
+    def get_dataset_kwargs(
+        shared_dict=None, base_dir='',
+        char_map=opt.char_map, **kwargs
+    ):
+        return kwargify(
+            video_path=opt.video_path,
+            shared_dict=shared_dict,
+            alignments_dir=opt.alignments_dir,
+            vid_pad=opt.vid_padding,
+            image_dir=opt.images_dir,
+            txt_pad=opt.txt_padding,
+            phonemes_dir=opt.phonemes_dir,
+            frame_doubling=opt.frame_doubling,
+            char_map=char_map,
+            base_dir=base_dir,
+            **kwargs
+        )
+
+    def init_tensorboard(self):
+        self.log_dir = f'runs/{self.save_name}'
+        self.weights_dir = f'weights/{self.save_name}'
+
+        if not os.path.exists(self.log_dir):
+            os.mkdir(self.log_dir)
+        if not os.path.exists(self.weights_dir):
+            os.mkdir(self.weights_dir)
+
+        self.writer = SummaryWriter(self.log_dir)
+        # save current state of options file
+        shutil.copyfile(
+            'options.py', os.path.join(self.log_dir, 'options.py')
+        )
+
+    @staticmethod
+    def make_date_stamp():
+        return Datetime.now().strftime("%y%m%d-%H%M")
+
+    def log_scalar(self, name, value, iterations, label):
+        self.writer.add_scalars(name, {label: value}, iterations)

Extractor.py

@@ -0,0 +1,170 @@
+from typing import List
+
+import torch
+import os
+import numpy as np
+import cv2
+import face_alignment
+import subprocess
+
+from helpers import *
+
+
+def get_position(size, padding=0.25):
+    x = [0.000213256, 0.0752622, 0.18113, 0.29077, 0.393397, 0.586856, 0.689483, 0.799124,
+         0.904991, 0.98004, 0.490127, 0.490127, 0.490127, 0.490127, 0.36688, 0.426036,
+         0.490127, 0.554217, 0.613373, 0.121737, 0.187122, 0.265825, 0.334606, 0.260918,
+         0.182743, 0.645647, 0.714428, 0.793132, 0.858516, 0.79751, 0.719335, 0.254149,
+         0.340985, 0.428858, 0.490127, 0.551395, 0.639268, 0.726104, 0.642159, 0.556721,
+         0.490127, 0.423532, 0.338094, 0.290379, 0.428096, 0.490127, 0.552157, 0.689874,
+         0.553364, 0.490127, 0.42689]
+
+    y = [0.106454, 0.038915, 0.0187482, 0.0344891, 0.0773906, 0.0773906, 0.0344891,
+         0.0187482, 0.038915, 0.106454, 0.203352, 0.307009, 0.409805, 0.515625, 0.587326,
+         0.609345, 0.628106, 0.609345, 0.587326, 0.216423, 0.178758, 0.179852, 0.231733,
+         0.245099, 0.244077, 0.231733, 0.179852, 0.178758, 0.216423, 0.244077, 0.245099,
+         0.780233, 0.745405, 0.727388, 0.742578, 0.727388, 0.745405, 0.780233, 0.864805,
+         0.902192, 0.909281, 0.902192, 0.864805, 0.784792, 0.778746, 0.785343, 0.778746,
+         0.784792, 0.824182, 0.831803, 0.824182]
+
+    x, y = np.array(x), np.array(y)
+
+    x = (x + padding) / (2 * padding + 1)
+    y = (y + padding) / (2 * padding + 1)
+    x = x * size
+    y = y * size
+    return np.array(list(zip(x, y)))
+
+
+def cal_area(anno):
+    return (anno[:, 0].max() - anno[:, 0].min()) * (anno[:, 1].max() - anno[:, 1].min())
+
+
+def output_video(p, txt, dst):
+    files = os.listdir(p)
+    files = sorted(files, key=lambda x: int(os.path.splitext(x)[0]))
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+
+    for file, line in zip(files, txt):
+        img = cv2.imread(os.path.join(p, file))
+        h, w, _ = img.shape
+        img = cv2.putText(img, line, (w // 8, 11 * h // 12), font, 1.2, (0, 0, 0), 3, cv2.LINE_AA)
+        img = cv2.putText(img, line, (w // 8, 11 * h // 12), font, 1.2, (255, 255, 255), 0, cv2.LINE_AA)
+        h = h // 2
+        w = w // 2
+        img = cv2.resize(img, (w, h))
+        cv2.imwrite(os.path.join(p, file), img)
+
+    cmd = "ffmpeg -y -i {}/%d.jpg -r 25 \'{}\'".format(p, dst)
+    os.system(cmd)
+
+
+def transformation_from_points(points1, points2):
+    points1 = points1.astype(np.float64)
+    points2 = points2.astype(np.float64)
+
+    c1 = np.mean(points1, axis=0)
+    c2 = np.mean(points2, axis=0)
+    points1 -= c1
+    points2 -= c2
+    s1 = np.std(points1)
+    s2 = np.std(points2)
+    points1 /= s1
+    points2 /= s2
+
+    U, S, Vt = np.linalg.svd(points1.T * points2)
+    R = (U * Vt).T
+    return np.vstack([
+        np.hstack(((s2 / s1) * R,
+        c2.T - (s2 / s1) * R * c1.T)),
+        np.matrix([0., 0., 1.])
+    ])
+
+
+def load_video(path: str) -> List[np.ndarray]:
+    """
+    adapted original loading code using this tutorial about openCV
+    https://learnopencv.com/read-write-and-display-a-video-using-opencv-cpp-python/
+    """
+    cap = cv2.VideoCapture(path)
+    frames = []
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+
+        if ret is True:
+            frames.append(frame)
+        else:
+            break
+
+    cap.release()
+    return frames
+
+
+def extract_frames(
+    video_filepath, recycle_landmarks=False,
+    use_gpu=False
+):
+    device = 'cuda' if use_gpu else 'cpu'
+
+    fa = face_alignment.FaceAlignment(
+        face_alignment.LandmarksType.TWO_D,
+        flip_input=False, device=device
+    )
+
+    array = load_video(video_filepath)
+    array = list(filter(lambda im: not im is None, array))
+    # array = [cv2.resize(im, (100, 50), interpolation=cv2.INTER_LANCZOS4)
+    # for im in array]
+
+    points = [fa.get_landmarks(I) for I in array]
+    front256 = get_position(256)
+    prev_landmarks = None
+    frames = []
+
+    for point, scene in zip(points, array):
+        if point is not None:
+            prev_landmarks = point
+        elif recycle_landmarks and (prev_landmarks is not None):
+            point = prev_landmarks
+        else:
+            frames.append(None)
+            continue
+
+        shape = np.array(point[0])
+        shape = shape[17:]
+        M = transformation_from_points(
+            np.matrix(shape), np.matrix(front256)
+        )
+
+        img = cv2.warpAffine(scene, M[:2], (256, 256))
+        (x, y) = front256[-20:].mean(0).astype(np.int32)
+        w = 160 // 2
+        img = img[y - w // 2:y + w // 2, x - w:x + w, ...]
+        img = cv2.resize(img, (128, 64))
+        frames.append(img)
+
+    return frames
+
+
+def export_frames(
+    video_filepath, export_images_dir,
+    recycle_landmarks=False, use_gpu=False,
+    **kwargs
+):
+    frames = extract_frames(
+        video_filepath, recycle_landmarks=recycle_landmarks,
+        use_gpu=use_gpu
+    )
+
+    extraction_incomplete = False
+    for k, image in enumerate(frames):
+        if image is None:
+            extraction_incomplete = True
+            continue
+
+        export_filepath = os.path.join(export_images_dir, f'{k}.jpg')
+        cv2.imwrite(export_filepath, image)
+
+    return extraction_incomplete

Loader.py

@@ -0,0 +1,327 @@
+import os
+import yaml
+import options as opt
+
+from typing import List, Tuple
+from dataset import GridDataset, CharMap, Datasets
+from tqdm.auto import tqdm
+from helpers import *
+
+
+class GridLoader(object):
+    def __init__(self, base_dir=''):
+        self.video_dir = os.path.join(base_dir, opt.video_dir)
+        self.alignment_dir = os.path.join(base_dir, opt.alignments_dir)
+        self.phonemes_dir = os.path.join(base_dir, opt.phonemes_dir)
+        self.images_dir = os.path.join(base_dir, opt.images_dir)
+        self.usable_video_filepaths = None
+
+    def load_video_paths(
+        self, verbose=False, blacklist=frozenset({}),
+        ext='mpg', fetch_all_paths=False, excluded_speakers=None,
+        verify_phonemes_length=False
+    ) -> List[str]:
+        """
+        :param fetch_all_paths:
+        :param verbose:
+        whether to show logs
+        (currently displays numbers of videos with alignment loaded)
+        :param blacklist:
+        set of filepaths to exclude from training
+        :param ext: video file extension
+        :param excluded_speakers:
+        :param verify_phonemes_length:
+        :return:
+        """
+        if excluded_speakers is None:
+            excluded_speakers = set()
+
+        assert ext in ('mpg', 'mp4')
+        usable_video_filepaths = []
+        videos_without_alignment = []
+        all_video_filepaths = []
+        ctc_exclusions = 0
+
+        for speaker_no in range(1, 35):
+            speaker_dirname = f's{speaker_no}'
+            speaker_dir = os.path.join(self.video_dir, speaker_dirname)
+            if speaker_no in excluded_speakers:
+                if verbose:
+                    print(f'SKIPPING SPEAKER NO {speaker_no}')
+
+                continue
+
+            if not os.path.exists(speaker_dir):
+                # speaker does not exist (its just s21 right now)
+                continue
+
+            video_filenames = os.listdir(speaker_dir)
+
+            for video_filename in video_filenames:
+                if not video_filename.endswith(f'.{ext}'):
+                    continue
+
+                # get name of file without the extension
+                base_name = os.path.splitext(video_filename)[0]
+                images_dir = os.path.join(
+                    self.images_dir, speaker_dirname, base_name
+                )
+                video_path = os.path.join(
+                    self.video_dir, speaker_dirname, f'{base_name}.{ext}'
+                )
+
+                if video_path in blacklist:
+                    continue
+
+                if verify_phonemes_length:
+                    extractable, ctc_invalid = self.is_phoneme_extractable(
+                        speaker_no, base_name, images_dir=images_dir,
+                        verbose=verbose
+                    )
+
+                    if ctc_invalid:
+                        ctc_exclusions += 1
+                    if not extractable:
+                        continue
+
+        if verbose:
+            num_usable_videos = len(usable_video_filepaths)
+            num_unusable_videos = len(videos_without_alignment)
+            # print(videos_without_alignment)
+
+            print(f'videos with alignment: {num_usable_videos}')
+            print(f'videos without alignment: {num_unusable_videos}')
+            print(f'CTC EXCLUSIONS: {ctc_exclusions}')
+
+        self.usable_video_filepaths = usable_video_filepaths
+
+        if fetch_all_paths:
+            return all_video_filepaths
+        else:
+            return usable_video_filepaths
+
+    def is_phoneme_extractable(
+        self, speaker_no, base_name, images_dir,
+        verbose=False
+    ) -> Tuple[bool, bool]:
+        """
+        :param speaker_no:
+        :param base_name:
+        :param images_dir:
+        :param verbose:
+        :return:
+        two boolean values:
+        the first whether the video is suitable
+        to be included in the dataset for phoneme prediction
+        the second bool determines whether the extracted images
+        and phonemes length corresponding to the video satisfies
+        CTC loss constraints (video / input length must be more
+        than twice the length of phoneme sequence / output)
+        """
+        speaker_dirname = f's{speaker_no}'
+        phonemes_path = os.path.join(
+            self.phonemes_dir, speaker_dirname,
+            f'{base_name}.align'
+        )
+
+        if not os.path.exists(images_dir):
+            # no images extracted for this video
+            # probably means annotation unavailable also
+            return False, False
+
+        try:
+            phonemes = GridDataset.load_sentence(
+                phonemes_path, CharMap.phonemes
+            )
+        except FileNotFoundError:
+            # phoneme sequence unavailable for video
+            return False, False
+
+        image_names = [
+            filename for filename in os.listdir(images_dir)
+            if filename.endswith('.jpg')
+        ]
+
+        vid_len = len(image_names)
+        num_phonemes = len(phonemes)
+
+        if vid_len <= num_phonemes * 2:
+            """
+            if video length is less than number of phonemes
+            then the CTCLoss will return nan, therefore we
+            exclude videos that would cause this
+            """
+            if verbose:
+                print(f'CTC EXCLUDE: {speaker_no, base_name}')
+                print(images_dir, vid_len, num_phonemes)
+
+            return False, True
+
+        return True, False
+
+    def get_grid_sentence_pairs(
+        self, excluded_speakers, ext='mpg', verbose=False
+    ) -> List[Tuple[int, str]]:
+        speaker_sentence_pairs = []
+
+        for speaker_no in range(1, 35):
+            speaker_dirname = f's{speaker_no}'
+            speaker_dir = os.path.join(self.video_dir, speaker_dirname)
+
+            if speaker_no in excluded_speakers:
+                if verbose:
+                    print(f'SKIPPING SPEAKER NO {speaker_no}')
+
+                continue
+
+            if not os.path.exists(speaker_dir):
+                # speaker does not exist (its just s21 right now)
+                continue
+
+            video_filenames = os.listdir(speaker_dir)
+            for video_filename in video_filenames:
+                if not video_filename.endswith(f'.{ext}'):
+                    continue
+
+                # get name of file without the extension
+                base_name = os.path.splitext(video_filename)[0]
+                speaker_sentence_pairs.append((speaker_no, base_name))
+
+        return speaker_sentence_pairs
+
+    def get_lsr2_sentence_pairs(self, ext='mp4') -> List[Tuple[str, str]]:
+        sentence_pairs = []
+
+        group_dirnames = os.listdir(self.video_dir)
+        for group_dirname in group_dirnames:
+            group_dir = os.path.join(self.video_dir, group_dirname)
+
+            if not os.path.exists(group_dir):
+                continue
+
+            video_filenames = os.listdir(group_dirname)
+            for video_filename in video_filenames:
+                if not video_filename.endswith(f'.{ext}'):
+                    continue
+
+                # get name of file without the extension
+                base_name = os.path.splitext(video_filename)[0]
+                sentence_pairs.append((group_dir, base_name))
+
+        return sentence_pairs
+
+    def load_lsr2_phonemes_text_map(
+        self, phonemes_char_map: CharMap = CharMap.cmu_phonemes,
+        text_char_map: CharMap = CharMap.lsr2_text,
+        ext='mp4', verbose=False,
+    ):
+        phoneme_map, text_map = {}, {}
+        assert ext in ('mpg', 'mp4')
+        unique_words = set()
+
+        sentence_pairs = self.get_lsr2_sentence_pairs(ext=ext)
+        pbar = tqdm(sentence_pairs)
+
+        for sentence_pair in pbar:
+            group_dir, base_name = sentence_pair
+
+            phonemes_path = os.path.join(
+                self.phonemes_dir, group_dir,
+                f'{base_name}.txt'
+            )
+            alignments_path = os.path.join(
+                self.alignment_dir, group_dir,
+                f'{base_name}.txt'
+            )
+
+            try:
+                phonemes_sentence = GridDataset.load_str_sentence(
+                    phonemes_path, char_map=phonemes_char_map
+                )
+                letters_sentence = GridDataset.load_str_sentence(
+                    alignments_path, char_map=text_char_map
+                )
+            except FileNotFoundError:
+                continue
+
+            words = letters_sentence.split(' ')
+            for word in words:
+                unique_words.add(word)
+
+            phoneme_map[sentence_pair] = phonemes_sentence
+            text_map[sentence_pair] = letters_sentence
+            # print("TEXT", text)
+            # print("PHONEMES", phonemes)
+
+        if verbose:
+            print('UNIQUE_WORDS', len(unique_words))
+
+        phonemes_text_map = {
+            phonemes_char_map: phoneme_map,
+            text_char_map: text_map
+        }
+        return phonemes_text_map
+
+    def load_grid_phonemes_text_map(
+        self, phonemes_char_map: CharMap = CharMap.phonemes,
+        text_char_map: CharMap = CharMap.letters,
+        excluded_speakers=None, verbose=False, ext='mpg'
+    ):
+        if excluded_speakers is None:
+            excluded_speakers = set()
+
+        phoneme_map, text_map = {}, {}
+        assert ext in ('mpg', 'mp4')
+        unique_words = set()
+
+        speaker_sentence_pairs = self.get_grid_sentence_pairs(
+            ext=ext, excluded_speakers=excluded_speakers,
+            verbose=verbose
+        )
+
+        pbar = tqdm(speaker_sentence_pairs)
+        for speaker_sentence_pair in pbar:
+            speaker_no, base_name = speaker_sentence_pair
+            speaker_dirname = f's{speaker_no}'
+
+            phonemes_path = os.path.join(
+                self.phonemes_dir, speaker_dirname,
+                f'{base_name}.align'
+            )
+            alignments_path = os.path.join(
+                self.alignment_dir, speaker_dirname,
+                f'{base_name}.align'
+            )
+
+            try:
+                phonemes_sentence = GridDataset.load_str_sentence(
+                    phonemes_path, char_map=phonemes_char_map
+                )
+                letters_sentence = GridDataset.load_str_sentence(
+                    alignments_path, char_map=text_char_map
+                )
+            except FileNotFoundError:
+                continue
+
+            words = letters_sentence.split(' ')
+            for word in words:
+                unique_words.add(word)
+
+            phoneme_map[speaker_sentence_pair] = phonemes_sentence
+            text_map[speaker_sentence_pair] = letters_sentence
+            # print("TEXT", text)
+            # print("PHONEMES", phonemes)
+
+        if verbose:
+            print('UNIQUE_WORDS', len(unique_words))
+
+        phonemes_text_map = {
+            phonemes_char_map: phoneme_map,
+            text_char_map: text_map
+        }
+        return phonemes_text_map
+
+
+if __name__ == '__main__':
+    loader = GridLoader()
+    loader.load_video_paths(True)

PauseChecker.py

@@ -0,0 +1,16 @@
+import os
+
+
+class PauseChecker(object):
+    @staticmethod
+    def check():
+        paused = False
+        filenames = os.listdir()
+
+        while '.pause' in filenames:
+            paused = True
+            input('PAUSING >>> ')
+            filenames = os.listdir()
+
+        if paused:
+            print('<<< resuming >>>')

README.md

@@ -0,0 +1,29 @@
+# LipNet Phonemes Predictors
+
+Project was developed on using python3.8, in a Linux Ubuntu 24.04
+run `python -m pip install -r requirements.txt` to make sure your dependencies are the same as mine  
+the list of video files to be used for training and validation when training normal LipNet (not phonemes prediction) 
+are in unseen_train.txt and unseen_test.txt respectively.
+the datasets are zipped in lip/*.zip, unzip them into the same location and run `python main.py` to start training  
+hyperparamters are found in options.py  
+
+Project Setup
+1. pull this repo using `git pull https://huggingface.co/SilentSpeak/torchnet phonemes`
+2. initialize a python virtualenv for this project using `python3.8 -m venv venv`
+3. initialize the virtualenv using `source venv/bin/activate`
+4. run `python -m pip install -r requirements.txt` to get dependencies
+5. install git LFS using `git lfs install`
+6. pull the GRID dataset and saved tensorboard runs using `git lfs pull`
+
+Following the project setup, you can run training as follows:  
+To run training for the LipNet phonemes predictor, run `python main.py`  
+To run training for the LipNet phonemes to text transformer predictor, run `python TransformerTrainer.py`  
+To run training for the LipNet-to-BiGRU-to-text transformer predictor, run `python TranslatorTrainer.py`  
+To run evaluation for the lipnet phonemes predictor + phonemes-to-text transformer end-to-end pipeline, 
+run `cd tests && python lipnet-pipeline.py`. The model weights used in `lipnet-pipeline.py` are included in the repo as 
+LFS files in the `saved-weights` folder.  
+
+The LRS2 dataset was too large to include in the repo, and access to the LRS2 dataset is conditional on accepting 
+the non-commercial usage license. However, the config file for training on the LRS2 dataset can be found in `options_lrs2.py` 
+, and the preprocessing code for the LRS2 dataset can be found in `scripts/extract_crop_lips_v2.py` and `scripts/generate_lsr2_train.py`.
+The LRS2 dataset itself can be be found at [https://www.robots.ox.ac.uk/~vgg/data/lip_reading/lrs2.html](https://www.robots.ox.ac.uk/~vgg/data/lip_reading/lrs2.html)

Trainer.py

@@ -0,0 +1,374 @@
+import torch.nn as nn
+import functools
+import torch.optim as optim
+import options as opt
+import time
+
+from helpers import *
+from dataset import GridDataset, CharMap
+from datetime import datetime as Datetime
+from models.LipNet import LipNet
+from tqdm.auto import tqdm
+from PauseChecker import PauseChecker
+from torch.utils.data import DataLoader
+from torch.multiprocessing import Manager
+from BaseTrainer import BaseTrainer
+
+
+class Trainer(BaseTrainer):
+    def __init__(
+        self, name=opt.run_name, write_logs=True,
+        num_workers=None, base_dir='', char_map=opt.char_map,
+        pre_gru_repeats=None
+    ):
+        super().__init__(name=name, base_dir=base_dir)
+
+        images_dir = opt.images_dir
+        if opt.use_lip_crops:
+            images_dir = opt.crop_images_dir
+        if num_workers is None:
+            num_workers = opt.num_workers
+        if pre_gru_repeats is None:
+            pre_gru_repeats = opt.pre_gru_repeats
+
+        assert pre_gru_repeats >= 1
+        assert isinstance(pre_gru_repeats, int)
+
+        self.images_dir = images_dir
+        self.num_workers = num_workers
+        self.pre_gru_repeats = pre_gru_repeats
+        self.char_map = char_map
+
+        manager = Manager()
+        if opt.cache_videos:
+            shared_dict = manager.dict()
+        else:
+            shared_dict = None
+
+        self.shared_dict = shared_dict
+        self.dataset_kwargs = self.get_dataset_kwargs(
+            shared_dict=shared_dict, base_dir=self.base_dir,
+            char_map=self.char_map
+        )
+
+        self.best_test_loss = float('inf')
+        self.train_dataset = None
+        self.test_dataset = None
+        self.model = None
+        self.net = None
+
+        if write_logs:
+            self.init_tensorboard()
+
+    def load_datasets(self):
+        if self.train_dataset is None:
+            self.train_dataset = GridDataset(
+                **self.dataset_kwargs, phase='train',
+                file_list=opt.train_list
+            )
+        if self.test_dataset is None:
+            self.test_dataset = GridDataset(
+                **self.dataset_kwargs, phase='test',
+                file_list=opt.val_list
+            )
+
+    def create_model(self):
+        output_classes = len(self.train_dataset.get_char_mapping())
+
+        if self.model is None:
+            self.model = LipNet(
+                output_classes=output_classes,
+                pre_gru_repeats=self.pre_gru_repeats
+            )
+            self.model = self.model.cuda()
+        if self.net is None:
+            self.net = nn.DataParallel(self.model).cuda()
+
+    def load_weights(self, weights_path):
+        self.load_datasets()
+        self.create_model()
+
+        weights_path = os.path.join(self.base_dir, weights_path)
+        pretrained_dict = torch.load(weights_path)
+        model_dict = self.model.state_dict()
+        pretrained_dict = {
+            k: v for k, v in pretrained_dict.items() if
+            k in model_dict.keys() and v.size() == model_dict[k].size()
+        }
+
+        missed_params = [
+            k for k, v in model_dict.items()
+            if k not in pretrained_dict.keys()
+        ]
+
+        print('loaded params/tot params: {}/{}'.format(
+            len(pretrained_dict), len(model_dict)
+        ))
+        print('miss matched params:{}'.format(missed_params))
+        model_dict.update(pretrained_dict)
+        self.model.load_state_dict(model_dict)
+
+    @staticmethod
+    def make_date_stamp():
+        return Datetime.now().strftime("%y%m%d-%H%M")
+
+    @staticmethod
+    def dataset2dataloader(
+        dataset, num_workers, shuffle=True
+    ):
+        return DataLoader(
+            dataset,
+            batch_size=opt.batch_size,
+            shuffle=shuffle,
+            num_workers=num_workers,
+            drop_last=False
+        )
+
+    def test(self):
+        dataset = self.test_dataset
+
+        with torch.no_grad():
+            print('num_test_data:{}'.format(len(dataset.data)))
+            self.model.eval()
+            loader = self.dataset2dataloader(
+                dataset, shuffle=False, num_workers=self.num_workers
+            )
+
+            loss_list = []
+            wer = []
+            cer = []
+            crit = nn.CTCLoss(zero_infinity=True)
+            tic = time.time()
+            print('RUNNING VALIDATION')
+
+            pbar = tqdm(loader)
+            for (i_iter, input_sample) in enumerate(pbar):
+                PauseChecker.check()
+
+                vid = input_sample.get('vid').cuda()
+                vid_len = input_sample.get('vid_len').cuda()
+                txt, txt_len = self.extract_char_output(input_sample)
+                y = self.net(vid)
+
+                # assert not contains_nan_or_inf(y)
+                assert (
+                    self.pre_gru_repeats * vid_len.view(-1) >
+                    2 * txt_len.view(-1)
+                ).all()
+
+                loss = crit(
+                    y.transpose(0, 1).log_softmax(-1), txt,
+                    self.pre_gru_repeats * vid_len.view(-1),
+                    txt_len.view(-1)
+                ).detach().cpu().numpy()
+
+                loss_list.append(loss)
+                pred_txt = dataset.ctc_decode(y)
+                truth_txt = [
+                    dataset.arr2txt(txt[_], start=1)
+                    for _ in range(txt.size(0))
+                ]
+
+                wer.extend(dataset.wer(pred_txt, truth_txt))
+                cer.extend(dataset.cer(pred_txt, truth_txt))
+
+                if i_iter % opt.display == 0:
+                    v = 1.0 * (time.time() - tic) / (i_iter + 1)
+                    eta = v * (len(loader) - i_iter) / 3600.0
+
+                    self.log_pred_texts(pred_txt, truth_txt, sub_samples=10)
+                    print('test_iter={},eta={},wer={},cer={}'.format(
+                        i_iter, eta, np.array(wer).mean(),
+                        np.array(cer).mean()
+                    ))
+                    print(''.join(161 * '-'))
+
+            return (
+                np.array(loss_list).mean(), np.array(wer).mean(),
+                np.array(cer).mean()
+            )
+
+    def extract_char_output(self, input_sample):
+        """
+        extract output character sequence from input_sample
+        output character sequence is text if char_map is CharMap.letters
+        output character sequence is phonemes if char_map is CharMap.phonemes
+        """
+        if self.char_map == CharMap.letters:
+            txt = input_sample.get('txt').cuda()
+            txt_len = input_sample.get('txt_len').cuda()
+        elif self.char_map == CharMap.phonemes:
+            txt = input_sample.get('phonemes').cuda()
+            txt_len = input_sample.get('phonemes_len').cuda()
+        elif self.char_map == CharMap.cmu_phonemes:
+            txt = input_sample.get('cmu_phonemes').cuda()
+            txt_len = input_sample.get('cmu_phonemes_len').cuda()
+        else:
+            raise ValueError(f'UNSUPPORTED CHAR_MAP: {self.char_map}')
+
+        return txt, txt_len
+
+    def train(self):
+        self.load_datasets()
+        self.create_model()
+
+        dataset = self.train_dataset
+        loader = self.dataset2dataloader(
+            dataset, num_workers=self.num_workers
+        )
+        """
+        optimizer = optim.Adam(
+            self.model.parameters(), lr=opt.base_lr,
+            weight_decay=0., amsgrad=True
+        )
+        """
+        optimizer = optim.RMSprop(
+            self.model.parameters(), lr=opt.base_lr
+        )
+
+        print('num_train_data:{}'.format(len(dataset.data)))
+        # don't allow loss function to create infinite loss for
+        # sequences that are too short
+        crit = nn.CTCLoss(zero_infinity=True)
+        tic = time.time()
+
+        train_wer = []
+        self.best_test_loss = float('inf')
+        log_scalar = functools.partial(self.log_scalar, label='train')
+
+        for epoch in range(opt.max_epoch):
+            print(f'RUNNING EPOCH {epoch}')
+
+            pbar = tqdm(loader)
+            for (i_iter, input_sample) in enumerate(pbar):
+                PauseChecker.check()
+
+                self.model.train()
+                vid = input_sample.get('vid').cuda()
+                vid_len = input_sample.get('vid_len').cuda()
+                txt, txt_len = self.extract_char_output(input_sample)
+
+                optimizer.zero_grad()
+                y = self.net(vid)
+                assert not contains_nan_or_inf(y)
+                assert (
+                    self.pre_gru_repeats * vid_len.view(-1) >
+                    2 * txt_len.view(-1)
+                ).all()
+
+                loss = crit(
+                    y.transpose(0, 1).log_softmax(-1), txt,
+                    self.pre_gru_repeats * vid_len.view(-1),
+                    txt_len.view(-1)
+                )
+
+                if contains_nan_or_inf(loss):
+                    print(f'LOSS IS INVALID. SKIPPING {i_iter}')
+                    # print('Y', y)
+                    # print('txt', txt)
+                    continue
+
+                loss.backward()
+                params = self.model.parameters()
+                # Check for NaNs in gradients
+                if any(torch.isnan(p.grad).any() for p in params):
+                    optimizer.zero_grad()  # Clear gradients to prevent update
+                    print('SKIPPING NAN GRADS')
+                    continue
+
+                if opt.is_optimize:
+                    optimizer.step()
+
+                assert not contains_nan_or_inf(self.model.conv1.weight)
+                tot_iter = i_iter + epoch * len(loader)
+                pred_txt = dataset.ctc_decode(y)
+                truth_txt = [
+                    dataset.arr2txt(txt[_], start=1)
+                    for _ in range(txt.size(0))
+                ]
+                train_wer.extend(dataset.wer(pred_txt, truth_txt))
+
+                if tot_iter % opt.display == 0:
+                    v = 1.0 * (time.time() - tic) / (tot_iter + 1)
+                    eta = (len(loader) - i_iter) * v / 3600.0
+                    wer = np.array(train_wer).mean()
+
+                    log_scalar('loss', loss, tot_iter)
+                    log_scalar('wer', wer, tot_iter)
+
+                    self.log_pred_texts(pred_txt, truth_txt, sub_samples=3)
+                    print('epoch={},tot_iter={},eta={},loss={},train_wer={}'
+                        .format(
+                            epoch, tot_iter, eta, loss,
+                            np.array(train_wer).mean()
+                        )
+                    )
+                    print(''.join(161 * '-'))
+
+                if (tot_iter > 0) and (tot_iter % opt.test_step == 0):
+                    # if tot_iter % opt.test_step == 0:
+                    self.run_test(tot_iter, optimizer)
+
+    @staticmethod
+    def log_pred_texts(pred_txt, truth_txt, pad=80, sub_samples=None):
+        line_length = 2 * pad + 1
+        print(''.join(line_length * '-'))
+        print('{:<{pad}}|{:>{pad}}'.format(
+            'predict', 'truth', pad=pad
+        ))
+
+        print(''.join(line_length * '-'))
+        zipped_samples = list(zip(pred_txt, truth_txt))
+        if sub_samples is not None:
+            zipped_samples = zipped_samples[:sub_samples]
+
+        for (predict, truth) in zipped_samples:
+            print('{:<{pad}}|{:>{pad}}'.format(
+                predict, truth, pad=pad
+            ))
+
+        print(''.join(line_length * '-'))
+
+    def run_test(self, tot_iter, optimizer):
+        log_scalar = functools.partial(self.log_scalar, label='test')
+
+        (loss, wer, cer) = self.test()
+        print('i_iter={},lr={},loss={},wer={},cer={}'.format(
+            tot_iter, show_lr(optimizer), loss, wer, cer
+        ))
+        log_scalar('loss', loss, tot_iter)
+        log_scalar('wer', wer, tot_iter)
+        log_scalar('cer', cer, tot_iter)
+
+        if loss < self.best_test_loss:
+            print(f'NEW BEST LOSS: {loss}')
+            self.best_test_loss = loss
+
+            savename = 'I{}-L{:.4f}-W{:.4f}-C{:.4f}'.format(
+                tot_iter, loss, wer, cer
+            )
+
+            savename = savename.replace('.', '') + '.pt'
+            savepath = os.path.join(self.weights_dir, savename)
+
+            (save_dir, name) = os.path.split(savepath)
+            if not os.path.exists(save_dir):
+                os.makedirs(save_dir)
+
+            torch.save(self.model.state_dict(), savepath)
+            print(f'best model saved at {savepath}')
+
+            if not opt.is_optimize:
+                exit()
+
+    def predict_sample(self, input_sample):
+        self.model.eval()
+        vid = input_sample.get('vid').cuda()
+        return self.predict_video(vid)
+
+    def predict_video(self, video):
+        video = video.cuda()
+        vid = video.unsqueeze(0)
+        y = self.net(vid)
+        pred_txt = self.train_dataset.ctc_decode(y)
+        return pred_txt

TransformerTrainer.py

@@ -0,0 +1,475 @@
+import os
+import sys
+import time
+
+sys.path.append('../models')
+
+import torch
+import functools
+import options as opt
+
+from torch import optim
+from tqdm.auto import tqdm
+
+from PauseChecker import PauseChecker
+from Trainer import Trainer
+from models.LipNetPlus import LipNetPlus
+from TranslatorTrainer import TranslatorTrainer
+from dataset import GridDataset, CharMap, Datasets
+from helpers import contains_nan_or_inf
+from models.PhonemeTransformer import *
+from helpers import *
+
+
+class TransformerTrainer(Trainer, TranslatorTrainer):
+    def __init__(
+        self, batch_size=opt.batch_size, word_tokenize=False,
+        dataset_type: Datasets = opt.dataset, embeds_size=256,
+        vocab_files=None, write_logs=True,
+        input_char_map=CharMap.phonemes,
+        output_char_map=CharMap.letters,
+        name='embeds-transformer-v2',
+        **kwargs
+    ):
+        super().__init__(**kwargs, name=name)
+
+        self.batch_size = batch_size
+        self.word_tokenize = word_tokenize
+        self.input_char_map = input_char_map
+        self.output_char_map = output_char_map
+        self.dataset_type = dataset_type
+        self.embeds_size = embeds_size
+
+        self.text_tokenizer = functools.partial(
+            GridDataset.tokenize_text, word_tokenize=word_tokenize
+        )
+        self.device = torch.device(
+            'cuda' if torch.cuda.is_available() else 'cpu'
+        )
+
+        if vocab_files is None:
+            vocabs = self.load_vocabs(self.base_dir)
+            self.phonemes_vocab, self.text_vocab = vocabs
+        else:
+            phonemes_vocab_path, text_vocab_path = vocab_files
+            self.phonemes_vocab = torch.load(phonemes_vocab_path)
+            self.text_vocab = torch.load(text_vocab_path)
+
+        self.model = None
+        self.optimizer = None
+        self.best_test_loss = float('inf')
+        self.loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)
+
+        """
+        self.phonemes_encoder = self.sequential_transforms(
+            GridDataset.tokenize_phonemes, self.phonemes_vocab,
+            self.tensor_transform
+        )
+        """
+        self.text_encoder = self.sequential_transforms(
+            self.text_tokenizer, self.text_vocab,
+            self.tensor_transform
+        )
+
+        if write_logs:
+            self.init_tensorboard()
+
+    def create_model(self):
+        if self.model is None:
+            output_classes = len(self.train_dataset.get_char_mapping())
+
+            self.model = LipNetPlus(
+                output_classes=output_classes,
+                pre_gru_repeats=self.pre_gru_repeats,
+                embeds_size=self.embeds_size,
+                output_vocab_size=len(self.text_vocab)
+            )
+            self.model = self.model.cuda()
+        if self.net is None:
+            self.net = nn.DataParallel(self.model).cuda()
+
+    def load_datasets(self):
+        if self.train_dataset is None:
+            self.train_dataset = GridDataset(
+                **self.dataset_kwargs, phase='train',
+                file_list=opt.train_list,
+                sample_all_props=True
+            )
+        if self.test_dataset is None:
+            self.test_dataset = GridDataset(
+                **self.dataset_kwargs, phase='test',
+                file_list=opt.val_list,
+                sample_all_props=True
+            )
+
+    def train(self):
+        self.load_datasets()
+        self.create_model()
+
+        dataset = self.train_dataset
+        loader = self.dataset2dataloader(
+            dataset, num_workers=self.num_workers
+        )
+        """
+        optimizer = optim.Adam(
+            self.model.parameters(), lr=opt.base_lr,
+            weight_decay=0., amsgrad=True
+        )
+        """
+        optimizer = optim.RMSprop(
+            self.model.parameters(), lr=opt.base_lr
+        )
+
+        print('num_train_data:{}'.format(len(dataset.data)))
+        # don't allow loss function to create infinite loss for
+        # sequences that are too short
+        tic = time.time()
+
+        self.best_test_loss = float('inf')
+        log_scalar = functools.partial(self.log_scalar, label='train')
+
+        for epoch in range(opt.max_epoch):
+            print(f'RUNNING EPOCH {epoch}')
+            train_wer = []
+
+            pbar = tqdm(loader)
+            for (i_iter, input_sample) in enumerate(pbar):
+                PauseChecker.check()
+
+                self.model.train()
+                vid = input_sample.get('vid').cuda()
+                # vid_len = input_sample.get('vid_len').cuda()
+                # txt, txt_len = self.extract_char_output(input_sample)
+                batch_arr_sentences = input_sample['txt_anno']
+                batch_arr_sentences = np.array(batch_arr_sentences)
+
+                _, batch_size = batch_arr_sentences.shape
+                batch_sentences = [
+                    ''.join(batch_arr_sentences[:, k]).strip()
+                    for k in range(batch_size)
+                ]
+
+                tgt = self.collate_tgt_fn(batch_sentences)
+                tgt = tgt.to(self.device)
+                tgt_input = tgt[:-1, :]
+
+                with torch.no_grad():
+                    gru_output = self.model.forward_gru(vid)
+                    y = self.model.predict_from_gru_out(gru_output)
+
+                src_embeds = self.model.make_src_embeds(gru_output)
+                transformer_out = self.make_transformer_embeds(
+                    dataset, src_embeds, y, batch_size=batch_size
+                )
+
+                transformer_src_embeds, src_idx_arr = transformer_out
+                transformer_src_embeds = transformer_src_embeds.to(self.device)
+                src_idx_arr = src_idx_arr.to(self.device)
+                max_seq_len, batch_size = src_idx_arr.shape
+
+                (
+                    src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask
+                ) = create_mask(
+                    src_idx_arr, tgt_input, self.device
+                )
+
+                logits = self.model.seq_forward(
+                    transformer_src_embeds, tgt_input, src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask, src_padding_mask
+                )
+
+                optimizer.zero_grad()
+
+                tgt_out = tgt[1:, :]
+                loss = self.loss_fn(
+                    logits.reshape(-1, logits.shape[-1]),
+                    tgt_out.reshape(-1)
+                )
+
+                tot_iter = i_iter + epoch * len(loader)
+
+                loss.backward()
+                optimizer.step()
+
+                # Convert logits tensor to string
+                with torch.no_grad():
+                    # Convert logits tensor to string
+                    probs = torch.softmax(logits, dim=-1)
+                    token_indices = torch.argmax(probs, dim=-1)
+
+                # Convert token indices to strings for
+                # each sequence in the batch
+                gap = ' ' if self.word_tokenize else ''
+                # print('TT', token_indices.shape)
+                pred_sentences = self.batch_indices_to_text(
+                    token_indices, batch_size=batch_size, gap=gap
+                )
+                wer = np.mean(GridDataset.get_wer(
+                    pred_sentences, batch_sentences,
+                    char_map=self.output_char_map
+                ))
+                train_wer.append(wer)
+
+                if tot_iter % opt.display == 0:
+                    v = 1.0 * (time.time() - tic) / (tot_iter + 1)
+                    eta = (len(loader) - i_iter) * v / 3600.0
+                    wer = np.array(train_wer).mean()
+
+                    log_scalar('loss', loss, tot_iter)
+                    log_scalar('wer', wer, tot_iter)
+                    self.log_pred_texts(
+                        pred_sentences, batch_sentences, sub_samples=3
+                    )
+
+                    print('epoch={},tot_iter={},eta={},loss={},train_wer={}'
+                    .format(
+                        epoch, tot_iter, eta, loss,
+                        np.array(train_wer).mean()
+                    ))
+                    print(''.join(161 * '-'))
+
+                if (tot_iter > -1) and (tot_iter % opt.test_step == 0):
+                    # if tot_iter % opt.test_step == 0:
+                    self.run_test(tot_iter, optimizer)
+
+    def make_transformer_embeds(
+        self, dataset, src_embeds, y, batch_size
+    ):
+        batch_indices = dataset.ctc_decode_indices(y)
+        filter_batch_embeds = []
+
+        pad_embed = self.model.src_tok_emb(
+            torch.IntTensor([PAD_IDX]).to(self.device)
+        )
+        begin_embed = self.model.src_tok_emb(
+            torch.IntTensor([BOS_IDX]).to(self.device)
+        )
+        end_embed = self.model.src_tok_emb(
+            torch.IntTensor([EOS_IDX]).to(self.device)
+        )
+        max_sentence_len = max([len(x) for x in batch_indices])
+
+        # initialize embeds with pad token embeddings
+        # [max_seq_len + 1, batch_size, embeds_size]
+        transformer_src_embeds = pad_embed.expand(
+            max_sentence_len + 2, batch_size, pad_embed.shape[1]
+        )
+
+        src_idx_mask = torch.full(
+            transformer_src_embeds.shape[:2], PAD_IDX,
+            dtype=torch.int
+        )
+
+        # k is sentence index in batch
+        for k, sentence_indices in enumerate(batch_indices):
+            filter_sentence_embeds = []
+            for sentence_index in sentence_indices:
+                filter_sentence_embeds.append(
+                    src_embeds[sentence_index][k]
+                )
+
+            sentence_length = len(filter_sentence_embeds)
+            filter_batch_embeds.append(filter_sentence_embeds)
+            # set beginning to sequence embed
+            transformer_src_embeds[0][k] = begin_embed
+            src_idx_mask[0][k] = UNK_IDX
+
+            # index i is char index in sentence
+            for i, char_embed in enumerate(filter_sentence_embeds):
+                transformer_src_embeds[i + 1][k] = char_embed
+                src_idx_mask[i + 1][k] = UNK_IDX
+
+            transformer_src_embeds[sentence_length + 1][k] = end_embed
+            src_idx_mask[sentence_length + 1][k] = UNK_IDX
+
+        return transformer_src_embeds, src_idx_mask
+
+    @staticmethod
+    def log_pred_texts(
+        pred_txt, truth_txt, pad=80, sub_samples=None
+    ):
+        line_length = 2 * pad + 1
+        print(''.join(line_length * '-'))
+        print('{:<{pad}}|{:>{pad}}'.format(
+            'predict', 'truth', pad=pad
+        ))
+
+        print(''.join(line_length * '-'))
+        zipped_samples = list(zip(pred_txt, truth_txt))
+        if sub_samples is not None:
+            zipped_samples = zipped_samples[:sub_samples]
+
+        for (predict, truth) in zipped_samples:
+            print('{:<{pad}}|{:>{pad}}'.format(
+                predict, truth, pad=pad
+            ))
+
+        print(''.join(line_length * '-'))
+
+    def test(self):
+        dataset = self.test_dataset
+
+        with torch.no_grad():
+            print('num_test_data:{}'.format(len(dataset.data)))
+            self.model.eval()
+            loader = self.dataset2dataloader(
+                dataset, shuffle=False, num_workers=self.num_workers
+            )
+
+            loss_list = []
+            wer = []
+            cer = []
+            tic = time.time()
+            print('RUNNING VALIDATION')
+
+            pbar = tqdm(loader)
+            for (i_iter, input_sample) in enumerate(pbar):
+                PauseChecker.check()
+
+                vid = input_sample.get('vid').cuda()
+                batch_arr_sentences = input_sample['txt_anno']
+                batch_arr_sentences = np.array(batch_arr_sentences)
+
+                _, batch_size = batch_arr_sentences.shape
+                batch_sentences = [
+                    ''.join(batch_arr_sentences[:, k]).strip()
+                    for k in range(batch_size)
+                ]
+
+                tgt = self.collate_tgt_fn(batch_sentences)
+                tgt = tgt.to(self.device)
+                tgt_input = tgt[:-1, :]
+
+                with torch.no_grad():
+                    gru_output = self.model.forward_gru(vid)
+                    y = self.model.predict_from_gru_out(gru_output)
+
+                src_embeds = self.model.make_src_embeds(gru_output)
+                transformer_out = self.make_transformer_embeds(
+                    dataset, src_embeds, y, batch_size=batch_size
+                )
+
+                transformer_src_embeds, src_idx_arr = transformer_out
+                transformer_src_embeds = transformer_src_embeds.to(self.device)
+                src_idx_arr = src_idx_arr.to(self.device)
+                max_seq_len, batch_size = src_idx_arr.shape
+
+                (
+                    src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask
+                ) = create_mask(
+                    src_idx_arr, tgt_input, self.device
+                )
+
+                logits = self.model.seq_forward(
+                    transformer_src_embeds, tgt_input, src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask, src_padding_mask
+                )
+
+                # Convert logits tensor to string
+                with torch.no_grad():
+                    # Convert logits tensor to string
+                    probs = torch.softmax(logits, dim=-1)
+                    token_indices = torch.argmax(probs, dim=-1)
+
+                # Convert token indices to strings for
+                # each sequence in the batch
+                gap = ' ' if self.word_tokenize else ''
+                # print('TT', token_indices.shape)
+                pred_sentences = self.batch_indices_to_text(
+                    token_indices, batch_size=batch_size, gap=gap
+                )
+
+                tgt_out = tgt[1:, :]
+                loss = self.loss_fn(
+                    logits.reshape(-1, logits.shape[-1]),
+                    tgt_out.reshape(-1)
+                )
+
+                loss_item = loss.detach().cpu().numpy()
+                loss_list.append(loss_item)
+
+                wer.extend(GridDataset.get_wer(
+                    pred_sentences, batch_sentences,
+                    char_map=self.output_char_map
+                ))
+                cer.extend(GridDataset.get_cer(
+                    pred_sentences, batch_sentences,
+                    char_map=self.output_char_map
+                ))
+
+                if i_iter % opt.display == 0:
+                    v = 1.0 * (time.time() - tic) / (i_iter + 1)
+                    eta = v * (len(loader) - i_iter) / 3600.0
+
+                    self.log_pred_texts(
+                        pred_sentences, batch_sentences, sub_samples=10
+                    )
+
+                    print('test_iter={},eta={},wer={},cer={}'.format(
+                        i_iter, eta, np.array(wer).mean(),
+                        np.array(cer).mean()
+                    ))
+                    print(''.join(161 * '-'))
+
+            return (
+                np.array(loss_list).mean(), np.array(wer).mean(),
+                np.array(cer).mean()
+            )
+
+    def run_test(self, tot_iter, optimizer):
+        log_scalar = functools.partial(self.log_scalar, label='test')
+
+        (loss, wer, cer) = self.test()
+        print('i_iter={},lr={},loss={},wer={},cer={}'.format(
+            tot_iter, show_lr(optimizer), loss, wer, cer
+        ))
+        log_scalar('loss', loss, tot_iter)
+        log_scalar('wer', wer, tot_iter)
+        log_scalar('cer', cer, tot_iter)
+
+        if loss < self.best_test_loss:
+            print(f'NEW BEST LOSS: {loss}')
+            self.best_test_loss = loss
+
+            savename = 'I{}-L{:.4f}-W{:.4f}-C{:.4f}'.format(
+                tot_iter, loss, wer, cer
+            )
+
+            savename = savename.replace('.', '') + '.pt'
+            savepath = os.path.join(self.weights_dir, savename)
+
+            (save_dir, name) = os.path.split(savepath)
+            if not os.path.exists(save_dir):
+                os.makedirs(save_dir)
+
+            torch.save(self.model.state_dict(), savepath)
+            print(f'best model saved at {savepath}')
+
+            if not opt.is_optimize:
+                exit()
+
+
+if __name__ == '__main__':
+    vocab_filepaths = (
+        'data/grid_phoneme_vocab.pth',
+        'data/grid_text_char_vocab.pth'
+    )
+    """
+    vocab_filepaths = (
+        'data/lsr2_phoneme_vocab.pth',
+        'data/lsr2_text_char_vocab.pth'
+    )
+    """
+
+    trainer = TransformerTrainer(
+        word_tokenize=False, vocab_files=vocab_filepaths,
+        input_char_map=opt.char_map,
+        output_char_map=opt.text_char_map
+    )
+
+    if hasattr(opt, 'weights'):
+        trainer.load_weights(opt.weights)
+
+    trainer.train()

TranslatorTrainer.py

@@ -0,0 +1,636 @@
+import os
+import numpy as np
+import functools
+import shutil
+
+from typing import List
+
+import torch
+from tqdm.auto import tqdm
+
+from torch.utils.data import DataLoader
+from torchtext.datasets import Multi30k
+
+import options
+from Loader import GridLoader
+from PauseChecker import PauseChecker
+from dataset import GridDataset, CharMap, Datasets
+from datetime import datetime as Datetime
+
+from models.PhonemeTransformer import *
+from torchtext.vocab import build_vocab_from_iterator
+from torch.nn.utils.rnn import pad_sequence
+from BaseTrainer import BaseTrainer
+
+
+class TranslationDataset(GridDataset):
+    def __init__(
+        self, input_char_map: CharMap,
+        output_char_map: CharMap, **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.input_char_map = input_char_map
+        self.output_char_map = output_char_map
+
+    def __getitem__(self, idx):
+        (vid, spk, name) = self.data[idx]
+        basename, _ = os.path.splitext(name)
+
+        input_filepath = self.fetch_anno_path(
+            spk, basename, char_map=self.input_char_map
+        )
+        output_filepath = self.fetch_anno_path(
+            spk, basename, char_map=self.output_char_map
+        )
+
+        input_str = self.load_str_sentence(
+            input_filepath, char_map=self.input_char_map
+        )
+        output_str = self.load_str_sentence(
+            output_filepath, char_map=self.output_char_map
+        )
+        return input_str, output_str
+
+
+class TranslatorTrainer(BaseTrainer):
+    def __init__(
+        self, dataset_type: Datasets = options.dataset,
+        batch_size=128, validate_every=20, display_every=10,
+        name='translate', write_logs=True, base_dir='',
+        word_tokenize=False, vocab_files=None,
+        input_char_map=CharMap.phonemes,
+        output_char_map=CharMap.letters
+    ):
+        super().__init__(name=name, base_dir=base_dir)
+
+        self.batch_size = batch_size
+        self.validate_every = validate_every
+        self.display_every = display_every
+        self.word_tokenize = word_tokenize
+        self.input_char_map = input_char_map
+        self.output_char_map = output_char_map
+        self.dataset_type = dataset_type
+
+        self.text_tokenizer = functools.partial(
+            GridDataset.tokenize_text, word_tokenize=word_tokenize
+        )
+        self.device = torch.device(
+            'cuda' if torch.cuda.is_available() else 'cpu'
+        )
+
+        if vocab_files is None:
+            vocabs = self.load_vocabs(self.base_dir)
+            self.phonemes_vocab, self.text_vocab = vocabs
+        else:
+            phonemes_vocab_path, text_vocab_path = vocab_files
+            self.phonemes_vocab = torch.load(phonemes_vocab_path)
+            self.text_vocab = torch.load(text_vocab_path)
+
+        self.model = None
+        self.optimizer = None
+        self.best_test_loss = float('inf')
+        self.loss_fn = torch.nn.CrossEntropyLoss(ignore_index=PAD_IDX)
+
+        self.phonemes_encoder = self.sequential_transforms(
+            GridDataset.tokenize_phonemes, self.phonemes_vocab,
+            self.tensor_transform
+        )
+        self.text_encoder = self.sequential_transforms(
+            self.text_tokenizer, self.text_vocab,
+            self.tensor_transform
+        )
+
+        if write_logs:
+            self.init_tensorboard()
+
+    def load_vocabs(self, base_dir):
+        loader = GridLoader(base_dir=base_dir)
+
+        if self.dataset_type == Datasets.GRID:
+            phonemes_text_map = loader.load_grid_phonemes_text_map(
+                phonemes_char_map=self.input_char_map,
+                text_char_map=self.output_char_map
+            )
+        elif self.dataset_type == Datasets.LRS2:
+            phonemes_text_map = loader.load_lsr2_phonemes_text_map(
+                phonemes_char_map=self.input_char_map,
+                text_char_map=self.output_char_map
+            )
+        else:
+            raise NotImplementedError
+
+        phonemes_map = phonemes_text_map[self.input_char_map]
+        text_map = phonemes_text_map[self.output_char_map]
+
+        phonemes_vocab = self.build_vocab(
+            phonemes_map, tokenizer=GridDataset.tokenize_phonemes
+        )
+        text_vocab = self.build_vocab(
+            text_map, tokenizer=self.text_tokenizer
+        )
+
+        return phonemes_vocab, text_vocab
+
+    def save_vocabs(
+        self, phoneme_vocab_path, text_vocab_path
+    ):
+        torch.save(self.phonemes_vocab, phoneme_vocab_path)
+        torch.save(self.text_vocab, text_vocab_path)
+
+    def load_weights(self, weights):
+        self.create_model()
+
+        pretrained_dict = torch.load(weights)
+        model_dict = self.model.state_dict()
+        pretrained_dict = {
+            k: v for k, v in pretrained_dict.items() if
+            k in model_dict.keys() and v.size() == model_dict[k].size()
+        }
+
+        missed_params = [
+            k for k, v in model_dict.items()
+            if k not in pretrained_dict.keys()
+        ]
+
+        print('loaded params/tot params: {}/{}'.format(
+            len(pretrained_dict), len(model_dict)
+        ))
+        print('miss matched params:{}'.format(missed_params))
+        model_dict.update(pretrained_dict)
+        self.model.load_state_dict(model_dict)
+
+    def create_model(self):
+        self.model = Seq2SeqTransformer(
+            src_vocab_size=len(self.phonemes_vocab),
+            tgt_vocab_size=len(self.text_vocab)
+        )
+
+        self.model = self.model.to(self.device)
+        self.optimizer = torch.optim.Adam(
+            self.model.parameters(),
+            lr=0.0001, betas=(0.9, 0.98), eps=1e-9
+        )
+
+    def collate_tgt_fn(self, batch):
+        tgt_batch = []
+        for tgt_sample in batch:
+            tgt_batch.append(self.text_encoder(tgt_sample.rstrip("\n")))
+
+        tgt_batch = pad_sequence(tgt_batch, padding_value=PAD_IDX)
+        return tgt_batch
+
+    # function to collate data samples into batch tensors
+    def collate_fn(self, batch):
+        src_batch, tgt_batch = [], []
+        for src_sample, tgt_sample in batch:
+            src_batch.append(self.phonemes_encoder(src_sample.rstrip("\n")))
+            tgt_batch.append(self.text_encoder(tgt_sample.rstrip("\n")))
+
+        src_batch = pad_sequence(src_batch, padding_value=PAD_IDX)
+        tgt_batch = pad_sequence(tgt_batch, padding_value=PAD_IDX)
+        return src_batch, tgt_batch
+
+    def train(self, max_iters=10*1000):
+        assert self.writer is not None
+        assert self.display_every < self.validate_every
+
+        self.create_model()
+        self.best_test_loss = float('inf')
+        log_scalar = functools.partial(self.log_scalar, label='train')
+        self.model.train()
+        losses = 0
+
+        dataset_kwargs = self.get_dataset_kwargs(
+            input_char_map=self.input_char_map,
+            char_map=self.output_char_map,
+            output_char_map=self.output_char_map,
+            file_list=options.train_list
+        )
+
+        train_iter = TranslationDataset(**dataset_kwargs, phase='train')
+        test_iter = TranslationDataset(**dataset_kwargs, phase='test')
+
+        train_dataloader = DataLoader(
+            train_iter, batch_size=self.batch_size,
+            # collate_fn=self.collate_fn, shuffle=True
+        )
+        test_dataloader = DataLoader(
+            test_iter, batch_size=self.batch_size,
+            # collate_fn=self.collate_fn, shuffle=True
+        )
+
+        tot_iters = 0
+        pbar = tqdm(total=max_iters)
+
+        while tot_iters < max_iters:
+            for train_pair in train_dataloader:
+                PauseChecker.check()
+
+                raw_src, raw_tgt = train_pair
+                src, tgt = self.collate_fn(zip(raw_src, raw_tgt))
+                batch_size, max_seq_len = src.shape
+
+                src = src.to(self.device)
+                tgt = tgt.to(self.device)
+                tgt_input = tgt[:-1, :]
+                (
+                    src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask
+                ) = create_mask(src, tgt_input, self.device)
+
+                logits = self.model(
+                    src, tgt_input, src_mask, tgt_mask,
+                    src_padding_mask, tgt_padding_mask, src_padding_mask
+                )
+
+                self.optimizer.zero_grad()
+
+                tgt_out = tgt[1:, :]
+                loss = self.loss_fn(
+                    logits.reshape(-1, logits.shape[-1]),
+                    tgt_out.reshape(-1)
+                )
+
+                loss.backward()
+                self.optimizer.step()
+                loss_item = loss.item()
+
+                # Convert logits tensor to string
+                with torch.no_grad():
+                    # Convert logits tensor to string
+                    probs = torch.softmax(logits, dim=-1)
+                    token_indices = torch.argmax(probs, dim=-1)
+
+                # Convert token indices to strings for
+                # each sequence in the batch
+                gap = ' ' if self.word_tokenize else ''
+                pred_sentences = self.batch_indices_to_text(
+                    token_indices, batch_size=max_seq_len, gap=gap
+                )
+                wer = np.mean(GridDataset.get_wer(
+                    pred_sentences, raw_tgt, char_map=self.output_char_map
+                ))
+
+                desc = f'loss: {loss_item:.4f}, wer: {wer:.4f}'
+                pbar.desc = desc
+
+                losses += loss_item
+                tot_iters += 1
+                pbar.update(1)
+
+                run_validation = (
+                    (tot_iters > 0) and
+                    (tot_iters % self.validate_every == 0)
+                )
+                run_display = (
+                    (tot_iters > 0) and
+                    (tot_iters % self.display_every == 0)
+                )
+
+                if run_validation:
+                    self.run_test(test_dataloader, tot_iters=tot_iters)
+                elif run_display:
+                    print('TRAIN PREDICTIONS')
+                    self.show_sentences(pred_sentences, raw_tgt, batch_size)
+
+                    if self.writer is not None:
+                        log_scalar('loss', loss, tot_iters)
+                        log_scalar('wer', wer, tot_iters)
+
+        return losses / len(list(train_dataloader))
+
+    @staticmethod
+    def show_sentences(
+        pred_sentences, target_sentences, batch_size, pad=40
+    ):
+        print('{:<{pad}}|{:>{pad}}'.format(
+            'predict', 'target', pad=pad
+        ))
+
+        line_length = 2 * pad + 1
+        print(''.join(line_length * '-'))
+
+        for k in range(batch_size):
+            pred_sentence = pred_sentences[k]
+            target_sentence = target_sentences[k]
+            print('{:<{pad}}|{:>{pad}}'.format(
+                pred_sentence, target_sentence, pad=pad
+            ))
+
+        print(''.join(line_length * '-'))
+
+    def run_test(self, test_dataloader, tot_iters):
+        log_scalar = functools.partial(self.log_scalar, label='test')
+
+        with torch.no_grad():
+            self.model.eval()
+
+            for batch in test_dataloader:
+                break
+
+            raw_src, raw_tgt = batch
+            src, tgt = self.collate_fn(zip(raw_src, raw_tgt))
+            batch_size, max_seq_len = src.shape
+            src = src.to(self.device)
+            tgt = tgt.to(self.device)
+
+            tgt_input = tgt[:-1, :]
+            (
+                src_mask, tgt_mask,
+                src_padding_mask, tgt_padding_mask
+            ) = create_mask(src, tgt_input, self.device)
+
+            logits = self.model(
+                src, tgt_input, src_mask, tgt_mask,
+                src_padding_mask, tgt_padding_mask, src_padding_mask
+            )
+
+            self.optimizer.zero_grad()
+
+            tgt_out = tgt[1:, :]
+            loss = self.loss_fn(
+                logits.reshape(-1, logits.shape[-1]),
+                tgt_out.reshape(-1)
+            )
+
+            loss_item = loss.item()
+
+            # Convert logits tensor to string
+            probs = torch.softmax(logits, dim=-1)
+            token_indices = torch.argmax(torch.softmax(logits, dim=-1), dim=-1)
+            # Convert token indices to strings for each sequence in the batch
+            gap = ' ' if self.word_tokenize else ''
+            pred_sentences = self.batch_indices_to_text(
+                token_indices, batch_size=max_seq_len, gap=gap
+            )
+            wer = np.mean(GridDataset.get_wer(
+                pred_sentences, raw_tgt, char_map=self.output_char_map
+            ))
+
+            log_scalar('loss', loss, tot_iters)
+            log_scalar('wer', wer, tot_iters)
+            print(f'TEST PREDS [loss={loss_item:.4f}, wer={wer:.4f}]')
+            self.show_sentences(pred_sentences, raw_tgt, batch_size)
+
+            if loss < self.best_test_loss:
+                print(f'NEW BEST LOSS: {loss}')
+                self.best_test_loss = loss
+                savename = 'I{}-L{:.4f}-W{:.4f}'.format(
+                    tot_iters, loss, wer
+                )
+
+                savename = savename.replace('.', '') + '.pt'
+                savepath = os.path.join(self.weights_dir, savename)
+
+                (save_dir, name) = os.path.split(savepath)
+                if not os.path.exists(save_dir):
+                    os.makedirs(save_dir)
+
+                torch.save(self.model.state_dict(), savepath)
+                print(f'best model saved at {savepath}')
+
+    def batch_indices_to_text(
+        self, indices_tensor, batch_size, gap=''
+    ):
+        sentences = []
+
+        for k in range(batch_size):
+            tokens = []
+
+            for indices_row in indices_tensor:
+                idx = indices_row[k]
+
+                if idx == EOS_IDX:
+                    break
+                if idx in [PAD_IDX, BOS_IDX, EOS_IDX]:
+                    continue
+
+                token = self.text_vocab.lookup_token(idx)
+                tokens.append(token)
+
+            sentence = gap.join(tokens)
+            sentences.append(sentence)
+
+        return sentences
+
+    @staticmethod
+    def batch_tokenize_text(batch_sentences, word_tokenize=False):
+        return [
+            GridDataset.tokenize_text(
+                sentence, word_tokenize=word_tokenize
+            ) for sentence in batch_sentences
+        ]
+
+    def evaluate(self, model):
+        model.eval()
+        losses = 0
+
+        language_pair = (str(CharMap.phonemes), str(CharMap.letters))
+        val_iter = Multi30k(
+            split='valid', language_pair=language_pair
+        )
+        val_dataloader = DataLoader(
+            val_iter, batch_size=self.batch_size,
+            collate_fn=self.collate_fn
+        )
+
+        for src, tgt in val_dataloader:
+            src = src.to(self.device)
+            tgt = tgt.to(self.device)
+            tgt_input = tgt[:-1, :]
+            (
+                src_mask, tgt_mask,
+                src_padding_mask, tgt_padding_mask
+            ) = create_mask(src, tgt_input, self.device)
+
+            logits = model(
+                src, tgt_input, src_mask, tgt_mask,
+                src_padding_mask, tgt_padding_mask, src_padding_mask
+            )
+
+            tgt_out = tgt[1:, :]
+            loss = self.loss_fn(
+                logits.reshape(-1, logits.shape[-1]),
+                tgt_out.reshape(-1)
+            )
+            losses += loss.item()
+
+        return losses / len(list(val_dataloader))
+
+    # actual function to translate input sentence into target language
+    def translate(
+        self, phoneme_sentence: str, beam_size=0
+    ):
+        self.model.eval()
+        dummy_sentence = self.text_vocab.lookup_token(
+            len(self.text_vocab) - 1
+        )
+        src, _ = self.collate_fn(zip(
+            [phoneme_sentence], [dummy_sentence]
+        ))
+
+        batch_size, max_seq_len = src.shape
+        src = src.to(self.device)
+
+        num_tokens = src.shape[0]
+        src_mask = (torch.zeros(num_tokens, num_tokens)).type(torch.bool)
+        max_len = num_tokens + 5
+
+        if beam_size > 0:
+            tgt_tokens = self.beam_search_decode(
+                src, src_mask, max_len=max_len,
+                start_symbol=BOS_IDX, beam_size=beam_size
+            )
+        else:
+            tgt_tokens = self.greedy_decode(
+                src, src_mask, max_len=max_len,
+                start_symbol=BOS_IDX
+            )
+
+        gap = ' ' if self.word_tokenize else ''
+        pred_sentence = self.batch_indices_to_text(
+            tgt_tokens, batch_size=max_seq_len, gap=gap
+        )[0]
+        return pred_sentence
+
+    # function to generate output sequence using greedy algorithm
+    def greedy_decode(self, src, src_mask, max_len, start_symbol):
+        src = src.to(self.device)
+        src_mask = src_mask.to(self.device)
+        memory = self.model.encode(src, src_mask)
+        ys = (
+            torch.ones(1, 1).fill_(start_symbol).
+            type(torch.long).to(self.device)
+        )
+
+        for i in range(max_len - 1):
+            memory = memory.to(self.device)
+            tgt_mask = (
+                generate_square_subsequent_mask(
+                    ys.size(0), device=self.device
+                ).type(torch.bool)
+            ).to(self.device)
+
+            out = self.model.decode(ys, memory, tgt_mask)
+            out = out.transpose(0, 1)
+            prob = self.model.generator(out[:, -1])
+            _, next_word = torch.max(prob, dim=1)
+            next_word = next_word.item()
+
+            ys = torch.cat([
+                ys, torch.ones(1, 1).type_as(src.data).fill_(next_word)
+            ], dim=0)
+
+            if next_word == EOS_IDX:
+                break
+
+        return ys
+
+    def beam_search_decode(
+        self, src, src_mask, max_len, start_symbol, beam_size=5
+    ):
+        src = src.to(self.device)
+        src_mask = src_mask.to(self.device)
+        memory = self.model.encode(src, src_mask)
+        ys = (
+            torch.ones(1, 1).fill_(start_symbol).
+            type(torch.long).to(self.device)
+        )
+
+        # Each hypothesis is a tuple (sequence, score)
+        hypotheses = [(ys, 0.0)]
+
+        for _ in range(max_len - 1):
+            new_hypotheses = []
+
+            for seq, score in hypotheses:
+                if seq[-1] == EOS_IDX:
+                    new_hypotheses.append((seq, score))
+                    continue
+
+                tgt_mask = generate_square_subsequent_mask(
+                    seq.size(0), device=self.device
+                ).type(torch.bool)
+
+                out = self.model.decode(seq, memory, tgt_mask)
+                out = out.transpose(0, 1)
+                prob = self.model.generator(out[:, -1])
+                # pick {beam_size} largest probabilities from prob
+                topk_prob, topk_indices = torch.topk(prob, beam_size)
+
+                for i in range(beam_size):
+                    next_word = topk_indices[0][i]
+                    # Assuming negative log probabilities
+                    next_score = score - topk_prob[0][i].item()
+                    new_seq = torch.cat([
+                        seq, torch.ones(1, 1).type_as(src.data).fill_(next_word)
+                    ], dim=0)
+
+                    # new_seq = torch.cat([seq, next_word.unsqueeze(0)], dim=0)
+                    new_hypotheses.append((new_seq, next_score))
+
+            if len(new_hypotheses) == 0:
+                break
+
+            # Keep top beam_size hypotheses
+            hypotheses = sorted(
+                new_hypotheses, key=lambda x: x[1]
+            )[:beam_size]
+
+        return hypotheses[0][0]  # Return the best hypothesis
+
+    @staticmethod
+    def yield_tokens(sequence_map, tokenizer):
+        for key in sequence_map:
+            yield tokenizer(sequence_map[key])
+
+    def build_vocab(self, sequence_map, tokenizer):
+        return build_vocab_from_iterator(
+            self.yield_tokens(sequence_map, tokenizer),
+            min_freq=1, specials=SPECIAL_SYMBOLS,
+            special_first=True
+        )
+
+    # helper function to club together sequential operations
+    @staticmethod
+    def sequential_transforms(*transforms):
+        def func(txt_input):
+            for transform in transforms:
+                txt_input = transform(txt_input)
+
+            return txt_input
+
+        return func
+
+    # function to add BOS/EOS and create tensor for input sequence indices
+    @staticmethod
+    def tensor_transform(token_ids: List[int]):
+        return torch.cat((
+            torch.tensor([BOS_IDX]), torch.tensor(token_ids),
+            torch.tensor([EOS_IDX])
+        ))
+
+
+if __name__ == '__main__':
+    vocab_filepaths = (
+        'data/grid_phoneme_vocab.pth',
+        'data/grid_text_char_vocab.pth'
+    )
+    """
+    vocab_filepaths = (
+        'data/lsr2_phoneme_vocab.pth',
+        'data/lsr2_text_char_vocab.pth'
+    )
+    """
+
+    trainer = TranslatorTrainer(
+        word_tokenize=False, vocab_files=vocab_filepaths,
+        input_char_map=options.char_map,
+        output_char_map=options.text_char_map
+    )
+
+    trainer.train()
+    # trainer.save_vocabs(*vocab_filepaths)
+    # loader = GridLoader()
+    # phonemes_text_map = loader.load_phonemes_text_map()
+    # print(">>>")

cvtransforms.py

@@ -0,0 +1,16 @@
+# coding: utf-8
+import random
+import cv2
+import numpy as np
+
+
+def HorizontalFlip(batch_img, p=0.5):
+    # (T, H, W, C)
+    if random.random() > p:
+        batch_img = batch_img[:, :, ::-1, ...]
+    return batch_img
+
+
+def ColorNormalize(batch_img):
+    batch_img = batch_img / 255.0
+    return batch_img

data/LRS2_CTC1_test.txt

@@ -0,0 +1,1208 @@
+6330311066473698535/00011
+6330311066473698535/00018
+6330311066473698535/00022
+6330311066473698535/00025
+6331559613336179781/00019
+6331559613336179781/00020
+6331559613336179781/00021
+6331559613336179781/00027
+6331559613336179781/00029
+6331559613336179781/00036
+6331559613336179781/00038
+6331559613336179781/00039
+6331733559511729306/00011
+6331733559511729306/00025
+6331733559511729306/00026
+6331733559511729306/00031
+6332062124509813446/00015
+6332062124509813446/00016
+6332062124509813446/00018
+6332062124509813446/00059
+6332062124509813446/00063
+6332491191742745853/00011
+6332491191742745853/00014
+6332804294858562278/00009
+6332804294858562278/00020
+6332804294858562278/00026
+6332804294858562278/00034
+6333175380032936690/00012
+6333175380032936690/00015
+6333604447265869137/00003
+6333604447265869137/00005
+6334149478615670679/00004
+6334149478615670679/00008
+6334149478615670679/00015
+6334149478615670679/00025
+6334331155732352379/00002
+6334563083966338309/00004
+6334563083966338309/00024
+6334563083966338309/00057
+6334563083966338309/00081
+6334563083966338309/00089
+6334563083966338309/00103
+6334563083966338309/00106
+6334934169140712754/00001
+6334934169140712754/00002
+6334934169140712754/00013
+6334934169140712754/00059
+6334934169140712754/00068
+6334934169140712754/00070
+6334934169140712754/00073
+6334934169140712754/00082
+6335003747610845928/00004
+6335003747610845928/00009
+6335003747610845928/00022
+6335003747610845928/00045
+6335305254315087182/00011
+6335305254315087182/00012
+6335305254315087182/00014
+6335305254315087182/00017
+6335305254315087182/00028
+6335305254315087182/00032
+6335305254315087182/00035
+6335305254315087182/00036
+6335305254315087182/00057
+6335305254315087182/00058
+6335676339489461610/00002
+6335676339489461610/00011
+6335676339489461610/00014
+6335676339489461610/00030
+6335676339489461610/00031
+6335676339489461610/00038
+6335676339489461610/00042
+6335676339489461610/00070
+6335676339489461610/00071
+6335676339489461610/00079
+6336047424663836038/00001
+6336047424663836038/00006
+6336047424663836038/00008
+6336047424663836038/00061
+6336047424663836038/00076
+6336117003133970558/00003
+6336117003133970558/00018
+6336117003133970558/00062
+6336117003133970558/00067
+6336739343895160063/00006
+6336739343895160063/00016
+6336739343895160063/00027
+6336739343895160063/00040
+6336739343895160063/00042
+6336739343895160063/00046
+6336739343895160063/00052
+6336739343895160063/00053
+6336739343895160063/00056
+6336851442541654996/00001
+6336917155541276097/00004
+6336917155541276097/00005
+6336917155541276097/00007
+6336917155541276097/00022
+6336917155541276097/00037
+6337160680186960682/00038
+6337160680186960682/00051
+6337160680186960682/00054
+6337160680186960682/00060
+6337160680186960682/00078
+6337230258657094880/00029
+6337531765361335111/00008
+6337531765361335111/00018
+6337531765361335111/00019
+6337531765361335111/00022
+6337531765361335111/00029
+6337531765361335111/00037
+6337531765361335111/00069
+6337531765361335111/00073
+6337902850535709539/00015
+6337902850535709539/00027
+6337902850535709539/00038
+6337902850535709539/00065
+6337902850535709539/00074
+6337902850535709539/00077
+6338130913429528164/00002
+6338130913429528164/00003
+6338130913429528164/00028
+6338130913429528164/00037
+6338130913429528164/00046
+6338273935710083967/00003
+6338273935710083967/00004
+6338273935710083967/00021
+6338273935710083967/00038
+6338273935710083967/00047
+6338273935710083967/00059
+6338273935710083967/00076
+6338645020884458400/00016
+6338645020884458400/00032
+6338645020884458400/00046
+6338645020884458400/00057
+6338645020884458400/00071
+6338807370648247218/00020
+6338807370648247218/00022
+6339077953587836416/00002
+6339077953587836416/00003
+6339077953587836416/00004
+6339077953587836416/00017
+6339077953587836416/00018
+6339077953587836416/00025
+6339077953587836416/00029
+6339077953587836416/00031
+6339077953587836416/00035
+6339356267468615354/00006
+6339356267468615354/00010
+6339356267468615354/00011
+6339356267468615354/00018
+6339356267468615354/00035
+6339356267468615354/00046
+6339464500644477822/00008
+6339464500644477822/00020
+6339464500644477822/00021
+6339464500644477822/00030
+6339464500644477822/00032
+6339526348173538836/00014
+6339615254127026753/00009
+6339615254127026753/00012
+6339615254127026753/00015
+6339758276407584924/00015
+6339758276407584924/00036
+6339758276407584924/00038
+6339758276407584924/00062
+6339758276407584924/00065
+6339758276407584924/00081
+6339758276407584924/00082
+6339758276407584924/00089
+6339758276407584924/00098
+6340129361581959353/00022
+6340299442417279404/00006
+6340299442417279404/00019
+6340299442417279404/00023
+6340500446756333781/00007
+6340500446756333781/00031
+6340500446756333781/00034
+6340500446756333781/00058
+6340500446756333781/00059
+6340871531930708209/00025
+6340871531930708209/00031
+6340871531930708209/00037
+6340871531930708209/00057
+6340871531930708209/00058
+6340871531930708209/00073
+6340871531930708209/00092
+6340871531930708209/00094
+6340871531930708209/00102
+6340871531930708209/00106
+6341242617105082637/00016
+6341242617105082637/00022
+6341242617105082637/00032
+6341242617105082637/00049
+6341242617105082637/00071
+6341242617105082637/00095
+6341242617105082637/00110
+6341242617105082637/00112
+6341381774045411442/00010
+6341404966868871455/00002
+6341404966868871455/00005
+6341404966868871455/00014
+6341404966868871455/00015
+6341949998218671745/00019
+6341949998218671745/00022
+6341949998218671745/00025
+6341949998218671745/00028
+6341949998218671745/00030
+6341949998218671745/00031
+6342112347982522696/00001
+6342112347982522696/00004
+6342112347982522696/00008
+6342112347982522696/00020
+6342112347982522696/00026
+6342440912980576694/00002
+6343252661930009508/00006
+6343252661930009508/00008
+6343252661930009508/00020
+6343252661930009508/00021
+6343252661930009508/00030
+6343252661930009508/00032
+6343252661930009508/00035
+6343252661930009508/00051
+6343252661930009508/00055
+6343252661930009508/00061
+6343252661930009508/00067
+6343252661930009508/00073
+6343252661930009508/00092
+6343252661930009508/00094
+6343252661930009508/00095
+6343252661930009508/00111
+6343252661930009508/00113
+6343252661930009508/00117
+6343608285091658983/00001
+6343608285091658983/00003
+6343979370266033402/00001
+6344002563089494087/00006
+6344002563089494087/00012
+6344002563089494087/00015
+6344002563089494087/00016
+6344350455440407821/00014
+6344350455440407821/00030
+6344350455440407821/00032
+6344350455440407821/00047
+6344547594439294233/00037
+6344709944203120665/00011
+6344709944203120665/00030
+6344737002497020519/00001
+6344737002497020519/00005
+6345541020505319391/00007
+6345541020505319391/00015
+6345850258020171127/00006
+6346600159310117136/00014
+6347195441777342774/00010
+6347195441777342774/00023
+6347195441777342774/00036
+6347195441777342774/00052
+6347195441777342774/00054
+6347195441777342774/00074
+6347195441777342774/00083
+6347195441777342774/00103
+6347195441777342774/00105
+6347195441777342774/00129
+6347195441777342774/00130
+6347195441777342774/00139
+6347195441777342774/00160
+6347195441777342774/00180
+6347195441777342774/00188
+6347195441777342774/00194
+6347271462698456331/00003
+6347271462698456331/00005
+6347271462698456331/00006
+6347271462698456331/00026
+6347271462698456331/00028
+6347338464188272871/00011
+6347350060599908703/00007
+6347524006775395501/00006
+6347524006775395501/00020
+6347667029186417939/00010
+6347667029186417939/00011
+6347667029186417939/00030
+6347667029186417939/00035
+6348038114360790454/00004
+6348038114360790454/00012
+6348409199535164855/00011
+6348409199535164855/00022
+6348409199535164855/00054
+6348440123299631026/00021
+6348463316123031920/00004
+6348463316123031920/00014
+6348463316123031920/00020
+6348463316123031920/00027
+6348714571709909926/00001
+6348714571709909926/00011
+6348780284709539256/00003
+6348780284709539256/00016
+6348780284709539256/00019
+6348780284709539256/00026
+6348834401297406331/00002
+6348834401297406331/00006
+6348834401297406331/00023
+6348834401297406331/00046
+6348834401297406331/00051
+6348834401427892766/00009
+6348834401427892766/00015
+6348834401427892766/00029
+6348834401427892766/00043
+6348834401427892766/00045
+6348834401427892766/00048
+6349108849707618270/00007
+6349174562707247076/00008
+6349174562707247076/00010
+6349174562707247076/00019
+6349190024589512678/00006
+6349213217412979095/00007
+6349213217412979095/00010
+6349228679295241171/00016
+6349420664333310663/00012
+6349559821273762790/00002
+6349559821273762790/00010
+6349793037997935601/00008
+6349793037997935601/00025
+6349793037997935601/00029
+6349793037997935601/00062
+6349793037997935601/00067
+6349793037997935601/00076
+6349793037997935601/00098
+6349793037997935601/00118
+6349793037997935601/00128
+6349793037997935601/00138
+6349793037997935601/00163
+6349793037997935601/00183
+6349847154585871175/00007
+6349847154585871175/00014
+6349847154585871175/00018
+6349847154585871175/00027
+6349847154585871175/00028
+6349847154585871175/00035
+6349847154585871175/00037
+6349847154585871175/00039
+6349916733056066377/00018
+6349947656820532043/00016
+6350152526760616781/00008
+6350152526760616781/00009
+6350152526760616781/00013
+6350152526760616781/00016
+6350152526760616781/00052
+6350152526760616781/00059
+6350152526760616781/00067
+6350222105230808621/00007
+6350222105230808621/00008
+6350222105230808621/00012
+6350264625407039025/00015
+6350295549171504559/00001
+6350295549171504559/00004
+6350295549171504559/00006
+6350295549171504559/00016
+6350523611934991188/00008
+6350523611934991188/00013
+6350523611934991188/00015
+6350523611934991188/00016
+6350523611934991188/00021
+6350523611934991188/00027
+6350523611934991188/00061
+6350523611934991188/00067
+6350666634345878987/00013
+6350921755403330389/00027
+6350921755403330389/00030
+6350921755403330389/00041
+6350921755403330389/00056
+6350921755403330389/00058
+6350921755403330389/00062
+6351037719520253414/00001
+6351037719520253414/00003
+6351234858519149621/00007
+6351234858519149621/00044
+6351265782283739990/00001
+6351265782283739990/00008
+6351265782283739990/00030
+6351265782283739990/00032
+6351265782283739990/00033
+6351424266576959115/00013
+6351424266576959115/00014
+6351424266576959115/00015
+6351431997518095202/00003
+6351431997518095202/00008
+6351431997518095202/00009
+6351431997518095202/00017
+6351431997518095202/00019
+6351636867458114391/00002
+6351636867458114391/00004
+6351636867458114391/00005
+6351636867458114391/00010
+6351636867458114391/00033
+6351636867458114391/00037
+6351636867458114391/00040
+6351714176869448803/00001
+6351714176869448803/00004
+6351714176869448803/00010
+6351772158927869467/00029
+6351772158927869467/00035
+6351810813633601326/00001
+6351810813633601326/00002
+6351810813633601326/00006
+6351810813633601326/00007
+6351810813633601326/00013
+6351810813633601326/00014
+6351810813633601326/00016
+6351810813633601326/00020
+6351826275515864748/00006
+6351841737398064668/00004
+6352157417494386368/00027
+6352157417494386368/00030
+6352157417494386368/00043
+6352157417494386368/00050
+6352157417494386368/00051
+6352498867394358158/00018
+6352498867394358158/00019
+6352498867394358158/00027
+6352533656629519062/00002
+6352533656629519062/00006
+6352533656629519062/00013
+6352815835980800496/00002
+6352815835980800496/00005
+6352815835980800496/00007
+6352893145392128503/00008
+6352893145392128503/00013
+6352893145392128503/00014
+6352893145392128503/00017
+6352893145392128503/00020
+6352893145392128503/00036
+6352916338215591806/00003
+6353179190214044575/00019
+6353179190214044575/00020
+6353190786625806236/00012
+6353233306802036640/00005
+6353233306802036640/00017
+6353233306802036640/00019
+6353233306802036640/00024
+6353233306802036640/00037
+6353233306802036640/00038
+6353233306802036640/00039
+6353264230566502930/00013
+6353264230566502930/00014
+6353561871800180662/00005
+6353561871800180662/00014
+6353561871800180662/00019
+6353561871800180662/00024
+6353604391976411066/00001
+6353604391976411066/00014
+6353635315740877357/00003
+6353635315740877357/00006
+6353909764151156687/00001
+6353909764151156687/00005
+6353932956974555090/00007
+6353975477150785494/00008
+6353975477150785494/00019
+6353975477150785494/00030
+6354006400915251783/00006
+6354006400915251783/00007
+6354304042148929518/00013
+6354346562325159922/00004
+6354346562325159922/00011
+6354346562325159922/00029
+6354346562325159922/00032
+6354346562325159922/00040
+6354346562325159922/00052
+6354369755148493407/00019
+6354369755148493407/00023
+6354369755148493407/00028
+6354369755148493407/00048
+6354369755148493407/00051
+6354369755148493407/00055
+6354617145264744350/00007
+6354755013715009552/00005
+6354988230439182363/00027
+6354988230439182363/00032
+6354988230439182363/00053
+6354988230439182363/00062
+6354988230439182363/00070
+6354988230439182363/00085
+6354988230439182363/00107
+6354988230439182363/00141
+6354988230439182363/00179
+6354988230439182363/00181
+6355115790967873574/00006
+6355115790967873574/00012
+6355115790967873574/00016
+6355115790967873574/00020
+6355115790967873574/00021
+6355115790967873574/00022
+6355115790967873574/00029
+6355115790967873574/00035
+6355193100379206640/00008
+6355414720691614656/00013
+6355459817848285433/00004
+6355459817848285433/00007
+6355544858200683461/00002
+6355556454612448247/00010
+6355556454612448247/00016
+6355568051024147448/00003
+6355568051024147448/00012
+6355568051024147448/00016
+6355788382846429521/00004
+6355788382846429521/00005
+6355788382846429521/00010
+6355830903022659925/00014
+6355861826787125225/00006
+6355861826787125225/00010
+6355861826787125225/00011
+6355861826787125225/00019
+6355861826787125225/00037
+6356201988197034394/00007
+6356201988197034394/00018
+6356201988197034394/00026
+6356201988197034394/00031
+6356201988197034394/00034
+6356201988197034394/00044
+6356232911961499649/00017
+6356232911961499649/00026
+6356530553195113872/00001
+6356530553195178439/00012
+6356530553195178439/00014
+6356573073371408843/00023
+6356573073371408843/00033
+6356573073371408843/00041
+6356573073371408843/00045
+6356603997135874072/00027
+6356619459018205648/00002
+6356619459018205648/00015
+6356878445546153116/00001
+6356878445546153116/00004
+6356878445546153116/00011
+6356878445546153116/00012
+6356901638369488289/00018
+6356998275133646895/00004
+6356998275133646895/00005
+6357006006074844331/00003
+6357006006074844331/00008
+6357006006074844331/00011
+6357006006074844331/00013
+6357006006074844331/00015
+6357353898425821669/00007
+6357353898425821669/00020
+6357353898425821669/00021
+6357353898425821669/00030
+6357353898425821669/00040
+6357353898425821669/00042
+6357353898425821669/00043
+6357701790776745251/00005
+6357701790776745251/00011
+6357701790776745251/00013
+6357701790776745251/00016
+6357701790776745251/00017
+6357701790776745251/00021
+6357714675678689620/00002
+6357714675678689620/00010
+6357714675678689620/00025
+6357714675678689620/00029
+6357714675678689620/00030
+6357798427540961623/00008
+6357798427540961623/00014
+6357798427540961623/00015
+6358014893892677091/00008
+6358057414068907495/00002
+6358057414068907495/00013
+6358088337833374405/00011
+6358088337833374405/00015
+6358111530656837102/00002
+6358428499243281970/00022
+6358428499243281970/00024
+6358428499243281970/00026
+6358428499243281970/00028
+6358428499243281970/00032
+6358459423007748830/00001
+6358474884890078775/00004
+6358474884890078775/00013
+6358757064241425994/00003
+6358830508182123252/00005
+6358830508182123252/00017
+6358830508182123252/00029
+6359128149415800422/00006
+6359201593356497677/00023
+6359499234590174850/00009
+6359541754766405254/00018
+6359541754766405254/00020
+6359564947589739760/00043
+6359580409472005362/00001
+6359580409472005362/00002
+6359580409472005362/00006
+6359580409472005362/00011
+6359588140413215496/00004
+6359603602295467662/00003
+6359603602295467662/00006
+6359603602295467662/00012
+6359951494646443684/00007
+6359982418410974886/00001
+6359982418410974886/00003
+6360322579951237696/00001
+6360322579951237696/00002
+6360322579951237696/00006
+6360322579951237696/00016
+6360322579951237696/00017
+6360322579951237696/00023
+6360322579951237696/00025
+6360322579951237696/00027
+6360327733781577947/00015
+6360327733781577947/00016
+6360327733781577947/00020
+6360393446781206759/00004
+6360393446781206759/00011
+6360393446781206759/00013
+6360393446781206759/00015
+6360393446781206759/00017
+6360612490113299870/00013
+6360612490113299870/00017
+6360685934053997353/00007
+6360709126877459881/00008
+6360709126877459881/00010
+6360709126877459881/00011
+6360740050641926958/00002
+6360740050641926958/00004
+6360983575287674299/00011
+6361028672444286629/00005
+6361028672444286629/00010
+6361028672444286629/00023
+6361028672444286629/00026
+6361354660462048727/00006
+6361354660462048727/00012
+6361428104402746195/00007
+6361725745636423155/00006
+6361725745636423155/00010
+6361725745636423155/00012
+6361725745636423155/00013
+6361799189577120616/00001
+6361799189577120616/00005
+6361814651459450364/00025
+6361822382531000645/00001
+6361822382531000645/00004
+6361822382531000645/00005
+6362096830810797583/00018
+6362096830810797583/00021
+6362143216457594387/00003
+6362143216457594387/00008
+6362143216457594387/00021
+6362143216457594387/00025
+6362162543810362236/00006
+6362162543810362236/00008
+6362162543810362236/00034
+6362162543810362236/00046
+6362162543810362236/00053
+6362193467574893437/00002
+6362193467574893437/00007
+6362460185044046481/00014
+6362460185044046481/00024
+6362460185044046481/00028
+6362546513886688816/00002
+6362546513886688816/00003
+6362546513886688816/00004
+6362546513886688816/00008
+6362726902513062509/00003
+6362726902513062509/00014
+6362913733590438579/00001
+6362913733590438579/00002
+6362913733590438579/00010
+6362913733590438579/00044
+6362913733590438579/00048
+6362913733590438579/00051
+6362913733590438579/00055
+6362913733590438579/00057
+6362913733590438579/00065
+6362913733590438579/00078
+6362913733590438579/00082
+6362913733590438579/00092
+6362913733590438579/00099
+6362913733590438579/00105
+6362913733590438579/00107
+6362913733590438579/00110
+6362913733590438579/00125
+6362913733590438579/00132
+6362913733590438579/00134
+6362913733590438579/00138
+6362913733590438579/00142
+6362913733590438579/00145
+6362913733590438579/00146
+6362913733590438579/00147
+6362913733590438579/00153
+6362913733590438579/00156
+6362913733590438579/00158
+6362913733590438579/00172
+6362913733590438579/00174
+6362913733590438579/00185
+6362913733590438579/00193
+6362913733590438579/00196
+6362913733590438579/00199
+6362913733590438579/00204
+6362913733590438579/00207
+6362913733590438579/00213
+6362913733590438579/00221
+6362913733590438579/00224
+6362925330002196038/00013
+6362925330002196038/00014
+6362925330002196038/00021
+6362958830877522951/00003
+6362958830877522951/00005
+6362958830877522951/00007
+6362958830877522951/00008
+6362993619982210246/00002
+6363210086333922442/00011
+6363283530274620169/00005
+6363283530274620169/00012
+6363306723098082453/00001
+6363581171508296879/00005
+6363581171508296879/00006
+6363654615448994597/00012
+6363654615448994597/00013
+6363654615448994597/00046
+6363948391212041701/00004
+6363952256682671319/00003
+6363952256682671319/00004
+6363952256682671319/00010
+6363952256682671319/00015
+6363952256682671319/00016
+6363956122153173818/00006
+6363956122153173818/00007
+6363956122153173818/00014
+6363956122153173818/00036
+6363997353839279323/00010
+6363997353839279323/00023
+6364025700623369025/00016
+6364025700623369025/00022
+6364319476386415444/00005
+6364319476386415444/00009
+6364327207327548190/00025
+6364327207327548190/00036
+6364396785797743449/00020
+6364760140030989000/00017
+6364760140030989000/00021
+6364791063795516278/00004
+6364791063795516278/00005
+6364791063795516278/00010
+6364791063795580193/00005
+6364791063795580193/00006
+6364798794736649079/00001
+6364798794736712994/00008
+6364798794736712994/00010
+6364798794736712994/00012
+6365141533126941637/00012
+6365141533126941637/00013
+6365141533126941637/00051
+6365141533126941637/00056
+6365141533126941637/00057
+6365141533126941637/00060
+6365413404556770633/00013
+6365413404556770633/00023
+6365413404556770633/00036
+6365888857436445152/00005
+6365888857436445152/00006
+6365888857436445152/00009
+6365888857436445152/00011
+6365904319318706417/00012
+6365935243083171934/00003
+6366259942610819561/00005
+6366259942610819561/00025
+6366267673551948044/00001
+6366267673551948044/00008
+6366267673551948044/00009
+6366631027785194041/00016
+6366631027785194041/00018
+6366944130901006716/00005
+6366944130901006716/00007
+6366944130901006716/00010
+6366944130901006716/00015
+6367002112959568594/00006
+6367002112959568594/00011
+6367002112959568594/00014
+6367373198133943465/00014
+6367373198133943465/00022
+6367373198133943465/00025
+6367373198133943465/00042
+6367373198133943465/00046
+6367373198133943465/00054
+6367373198133943465/00058
+6367373198133943465/00065
+6367373198133943465/00073
+6367373198133943465/00076
+6367373198133943465/00086
+6367373198133943465/00090
+6367373198133943465/00098
+6367373198133943465/00103
+6367373198133943465/00113
+6367373198133943465/00127
+6367373198133943465/00128
+6367373198133943465/00134
+6367373198133943465/00138
+6367373198133943465/00139
+6367373198133943465/00141
+6367373198133943465/00143
+6367373198133943465/00144
+6367373198133943465/00158
+6367373198133943465/00163
+6367373198133943465/00171
+6367396390957341434/00008
+6367396390957341434/00011
+6367396390957341434/00013
+6367396390957341434/00014
+6367744283308252235/00011
+6367813861908922495/00003
+6367813861908922495/00004
+6367813861908922495/00010
+6367813861908922495/00035
+6368096041129860047/00002
+6368111503012125648/00004
+6368111503012125648/00018
+6368111503012125648/00025
+6368111503012125648/00051
+6368154023188356050/00008
+6368177216011755289/00003
+6368177216011755289/00005
+6368177216011755289/00012
+6368177216011755289/00013
+6368177216011755289/00016
+6368494184598133861/00007
+6368494184598133861/00017
+6368494184598133861/00030
+6368494184598133861/00041
+6368494184598133861/00046
+6368525108362665063/00017
+6368525108362665063/00019
+6368525108362665063/00029
+6368525108362665063/00045
+6368525108362665063/00053
+6368525108362665063/00055
+6368525108362665063/00067
+6368525108362665063/00069
+6368857538831442335/00028
+6368903924478172740/00007
+6369220893064682263/00003
+6369220893064682263/00007
+6369220893064682263/00023
+6369220893064682263/00033
+6369220893064682263/00035
+6369259547770281088/00011
+6369259547770281088/00020
+6369259547770281088/00021
+6369259547770346264/00010
+6369259547770346264/00016
+6369599709180191149/00011
+6369599709180191149/00013
+6369599709180191149/00014
+6369599709180191149/00017
+6369599709180191149/00030
+6369607440121317877/00006
+6369912812296002056/00001
+6369912812296002056/00009
+6369912812296002056/00016
+6369912812296002056/00019
+6369912812296002056/00022
+6369912812296002056/00023
+6369912812296002056/00024
+6369912812296002056/00025
+6369970794354565537/00002
+6369970794354565537/00003
+6369986256236764320/00003
+6369986256236764320/00005
+6369986256236764320/00006
+6369986256236764320/00008
+6369986256236764320/00018
+6369986256236764320/00022
+6369986256236764320/00025
+6369986256236764320/00026
+6369986256236764320/00031
+6369986256236764320/00041
+6369986256236764320/00042
+6370331571607430336/00003
+6370331571607430336/00009
+6370331571607430336/00016
+6370331571607430336/00019
+6370331571607430336/00020
+6370331571607430336/00033
+6370366360842521130/00001
+6370366360842521130/00006
+6370728426585516325/00006
+6370728426585516325/00008
+6370728426585516325/00013
+6370728426585516325/00014
+6370728426585516325/00018
+6370997721034975856/00008
+6371091780818822750/00005
+6371091780818822750/00006
+6371091780818822750/00018
+6371114973642156346/00011
+6371114973642156346/00014
+6371114973642156346/00017
+6371114973642156346/00018
+6371114973642156346/00019
+6371114973642156346/00024
+6371114973642221152/00004
+6371114973642221152/00010
+6371389422052370754/00011
+6371462865993190004/00012
+6371470597064737331/00015
+6371470597064737331/00017
+6371470597064737331/00018
+6371470597064737331/00028
+6371470597064737331/00032
+6372918859906543042/00019
+6373112133434795034/00002
+6373112133434795034/00005
+6373112133434795034/00007
+6373202327748070121/00011
+6373318291865072119/00019
+6373318291865072119/00024
+6373318291865072119/00030
+6373318291865072119/00043
+6373326022806137973/00005
+6373326022806137973/00014
+6373326022806137973/00015
+6373627529510317190/00002
+6373627529510317190/00004
+6373627529510317190/00005
+6374060462213818017/00007
+6374060462213818017/00008
+6374083655037216420/00004
+6374083655167624227/00010
+6374083655167624227/00018
+6374083655167624227/00022
+6374083655167624227/00037
+6374083655167624227/00045
+6374083655167624227/00053
+6374083655167624227/00057
+6374083655167624227/00058
+6374083655167624227/00059
+6374083655167624227/00079
+6374083655167624227/00083
+6374083655167624227/00085
+6374083655167624227/00102
+6374083655167624227/00105
+6374083655167624227/00107
+6374083655167624227/00119
+6374454740211592999/00010
+6374802632562566873/00011
+6374802632562566873/00024
+6375181448678007969/00005
+6375181448678076214/00002
+6375448166147161013/00031
+6375480378401815497/00001
+6375480378401815497/00004
+6375480378401815497/00011
+6375480378401815497/00024
+6375516456127164915/00004
+6375516456127164915/00006
+6375516456127164915/00014
+6375915888085690147/00005
+6375915888085690147/00015
+6375915888085690147/00022
+6375915888085690147/00023
+6375915888085690147/00033
+6375915888085690147/00041
+6375915888085690147/00045
+6375915888085690147/00047
+6375915888085690147/00048
+6375923619026758902/00014
+6375923619026758902/00020
+6376310166083398929/00004
+6376623269199281113/00006
+6376623269199281113/00008
+6376623269199281113/00012
+6377052336432217027/00002
+6377052336432217027/00006
+6377052336432217027/00008
+6377365439548029922/00009
+6377365439548029922/00022
+6377365439548029922/00024
+6377365439548029922/00025
+6377365439548029922/00026
+6377365439548029922/00031
+6377365439548029922/00039
+6377400228783189968/00001
+6377400228783189968/00015
+6377779044898631026/00001
+6377794506780964609/00004
+6377794506780964609/00009
+6377794506780964609/00010
+6377794506780964609/00012
+6377794506780964609/00013
+6378096013485054233/00006
+6378324076248495598/00012
+6378795663657663776/00003
+6378795663657663776/00004
+6378795663657663776/00006
+6378853645716094465/00004
+6378853645716094465/00007
+6378907762304088259/00004
+6378907762304088259/00008
+6379224730890468911/00024
+6379224730890468911/00025
+6379537834006412580/00008
+6379537834006412580/00010
+6379537834006412580/00017
+6379537834006412580/00020
+6379595816064843367/00017
+6379649932652838513/00008
+6379649932652838513/00016
+6379908919180786981/00001
+6379908919180786981/00003
+6379908919180786981/00007
+6380021017827118123/00015
+6380021017957616097/00018
+6380021017957616097/00021
+6380021017957616097/00030
+6380036479839881698/00007
+6380036479839881698/00012
+6380036479839881698/00027
+6380036479839881698/00029
+6380036479839881698/00036
+6380036479839881698/00047
+6380036479839881698/00049
+6380280004355161382/00011
+6380280004355161382/00018
+6380921672469118671/00002
+6381381663466492945/00005
+6381381663466492945/00031
+6381381663466492945/00032
+6381395836858569746/00005
+6381395836858569746/00009
+6381766922032944158/00007
+6381766922032944158/00011
+6381766922032944158/00020
+6381853250875656673/00027
+6382138007207318567/00010
+6382189546814897943/00006
+6382189546814897943/00013
+6382189546814897943/00014
+6382189546814897943/00018
+6382189546814897943/00019
+6382189546814897943/00023
+6382189546814897943/00024
+6382189546814897943/00026
+6382189546814897943/00036
+6382232067121597643/00009
+6382232067121597643/00013
+6382247528873432347/00016
+6382247528873432347/00020
+6382506515401378320/00001
+6382595421224405529/00009
+6382595421224405529/00020
+6382618614178237455/00003
+6382618614178237455/00013
+6382618614178237455/00014
+6382618614178237455/00017
+6382618614178237455/00020
+6382618614178237455/00024
+6382618614178237455/00026
+6382618614178237455/00029
+6382618614178237455/00033
+6382618614178237455/00035
+6382618614178237455/00036
+6382618614178237455/00037
+6382618614178237455/00045
+6382866004163990600/00003
+6382877600575782419/00001
+6382880177556067401/00003
+6382880177556067401/00006
+6382880177556067401/00009
+6382880177556067401/00014
+6382880177556067401/00020
+6382931717163617970/00008
+6382931717163617970/00025
+6382974237339848372/00005
+6383716407688597209/00001
+6383716407688597209/00006
+6383716407688597209/00011
+6383716407688597209/00018
+6383716407688597209/00020
+6383716407688597209/00024
+6383716407688597209/00025
+6383716407688597209/00035
+6383716407688597209/00036
+6383990856098877828/00004
+6383990856098877828/00005
+6383993433079191521/00008
+6384044972686741229/00003
+6384044972686741229/00013
+6384044972686741229/00035
+6384102954745239874/00007
+6384102954745239874/00014
+6384102954745239874/00019
+6384361941273252259/00010
+6384361941273252259/00012
+6384364518253565937/00001
+6384364518253565937/00011
+6384364518253565937/00017
+6384787143035490080/00008
+6384787143035490080/00011
+6384829663342218937/00003
+6384829663342218937/00011
+6384829663342218937/00013
+6384829663342218937/00026
+6384829663342218937/00028
+6384829663342218937/00034
+6384829663342218937/00039
+6385104111622001114/00002
+6385104111622001114/00007
+6385106688602316013/00004
+6385106688602316013/00013
+6385106688602316013/00026
+6385106688602316013/00028
+6385106688602316013/00040
+6385106688602316013/00041
+6385158228209864505/00003
+6385158228209864505/00005
+6385158228209864505/00020
+6385158228209864505/00028
+6385158228209864505/00031
+6385216210398859008/00005
+6385216210398859008/00007
+6385216210398859008/00009
+6385475196796375542/00001
+6385571833560469334/00009
+6386314003909220420/00006
+6386588452319500723/00008
+6386588452319500723/00009
+6386588452319500723/00014
+6386700550965861901/00001
+6386700550965861901/00013
+6386700550965861901/00019
+6386700550965861901/00030
+6386959537493875163/00003
+6386959537493875163/00004
+6386959537493875163/00006
+6386959537493875163/00014
+6387319026256487668/00008
+6387319026256487668/00016
+6387330622668248413/00008
+6387701707842623991/00004
+6387701707842623991/00010
+6387705573313124513/00008
+6387705573313124513/00019
+6387755824430487717/00016
+6388072793016998420/00001
+6388072793016998420/00005
+6388072793016998420/00007
+6388072793016998420/00013
+6388076658487498938/00016
+6388076658487498938/00021
+6388126909604862142/00007
+6388126909604862142/00013
+6388126909604862142/00020
+6388126909604862142/00022
+6388126909604862142/00032
+6388126909604862142/00033
+6388126909604862142/00035
+6388126909604862142/00038
+6388726057542659435/00015
+6388726057542659435/00028
+6388772443189516866/00002
+6388911600129842790/00013
+6389545537302735360/00003
+6389599653890730492/00015
+6389599653890730492/00017
+6389599653890730492/00020
+6389599653890730492/00030
+6389599653890730492/00034
+6389599653890730492/00036
+6389684694243125765/00017
+6389933372849561261/00002
+6389933372849561261/00016
+6389933372849561261/00020
+6389933372849561261/00027
+6389933372849561261/00028
+6389970739065104229/00029
+6390299304063246834/00003
+6390301881043558087/00005
+6390301881043558087/00009
+6390301881043558087/00023
+6390301881043558087/00025
+6390670389237621263/00005
+6390670389237621263/00007
+6390670389237621263/00012
+6390672966217932513/00002
+6390672966217932513/00050
+6390672966217932513/00052
+6390672966217932513/00055
+6390672966217932513/00056
+6390767026001714921/00009
+6391420290527506887/00001
+6391420290527506887/00023
+6391420290527506887/00024
+6391420290527506887/00036
+6391783644760745881/00012
+6392197250111351363/00010
+6392197250111351363/00024
+6392282290463747809/00003
+6392282290463747809/00018
+6392282290463747809/00025
+6392525815109495392/00001
+6392525815109495392/00004
+6392525815109495392/00008
+6392525815109495392/00010
+6392525815109495392/00011
+6392568335285725796/00003
+6392568335285725796/00011
+6392568335285725796/00013
+6392568335285725796/00017
+6392896900283869820/00003
+6393267985458244248/00006
+6393267985458244248/00017

data/LRS2_CTC1_val.txt

@@ -0,0 +1,984 @@
+6300370419826092098/00001
+6300370419826092098/00002
+6300370419826092098/00003
+6300370419826092098/00004
+6300370419826092098/00006
+6300370419826092098/00007
+6300370419826092098/00010
+6300370419826092098/00012
+6300370419826092098/00013
+6300370419826092098/00016
+6300370419826092098/00020
+6300370419826092098/00024
+6300370419826092098/00025
+6301320037095305408/00002
+6301320037095305408/00003
+6301320037095305408/00004
+6301320037095305408/00007
+6301320037095305408/00009
+6301320037095305408/00010
+6302978323968228875/00005
+6302978323968228875/00007
+6302978323968228875/00008
+6302978323968228875/00010
+6302978323968228875/00011
+6302978323968228875/00012
+6302978323968228875/00015
+6302978323968228875/00017
+6302978323968228875/00019
+6302978323968228875/00020
+6302978323968228875/00021
+6302978323968228875/00022
+6302978323968228875/00023
+6303167732026041278/00004
+6303167732026041278/00005
+6303167732026041278/00006
+6303167732026041278/00011
+6303167732026041278/00013
+6303167732026041278/00014
+6303167732026041278/00017
+6303167732026041278/00018
+6303167732026041278/00019
+6303167732026041278/00020
+6303167732026041278/00023
+6306811582279909115/00001
+6306811582279909115/00004
+6306811582279909115/00005
+6306811582279909115/00006
+6306811582279909115/00007
+6306811582279909115/00009
+6306811582279909115/00010
+6306811582279909115/00011
+6306811582279909115/00012
+6306811582279909115/00013
+6306811582279909115/00014
+6306811582279909115/00015
+6306811582279909115/00018
+6306811582279909115/00019
+6306811582279909115/00021
+6306811582279909115/00022
+6306811582279909115/00025
+6306811582279909115/00026
+6306811582279909115/00027
+6306811582279909115/00030
+6306811582279909115/00033
+6306811582279909115/00034
+6306811582279909115/00035
+6306870852828565379/00002
+6306870852828565379/00004
+6306870852828565379/00006
+6306870852828565379/00007
+6306870852828565379/00008
+6306870852828565379/00013
+6306870852828565379/00014
+6306870852828565379/00015
+6306870852828565379/00016
+6306870852828565379/00017
+6306870852828565379/00018
+6306870852828565379/00021
+6306870852828565379/00023
+6306870852828565379/00024
+6306870852828565379/00026
+6306870852828565379/00027
+6306870852828565379/00028
+6306870852828565379/00029
+6308177381880006979/00001
+6308177381880006979/00002
+6308177381880006979/00004
+6308177381880006979/00005
+6308177381880006979/00006
+6308177381880006979/00007
+6308177381880006979/00008
+6308177381880006979/00010
+6308177381880006979/00011
+6308177381880006979/00012
+6308177381880006979/00013
+6308177381880006979/00017
+6308177381880006979/00022
+6308177381880006979/00024
+6308177381880006979/00026
+6308177381880006979/00027
+6308177381880006979/00028
+6308312673349834578/00004
+6308312673349834578/00008
+6308312673349834578/00010
+6308312673349834578/00013
+6309468449049188125/00004
+6309468449049188125/00006
+6309468449049188125/00007
+6309468449049188125/00016
+6309468449049188125/00017
+6309468449049188125/00018
+6309468449049188125/00020
+6309468449049188125/00024
+6309468449049188125/00026
+6309824072341293478/00001
+6309824072341293478/00002
+6309824072341293478/00004
+6309824072341293478/00005
+6309824072341293478/00007
+6309824072341293478/00008
+6309824072341293478/00009
+6309824072341293478/00010
+6310166810731517953/00002
+6310166810731517953/00005
+6310166810731517953/00007
+6310166810731517953/00009
+6310166810731517953/00011
+6310166810731517953/00015
+6310166810731517953/00016
+6310166810731517953/00017
+6310166810731517953/00025
+6310166810731517953/00026
+6310195157515669986/00001
+6310195157515669986/00004
+6310195157515669986/00005
+6310195157515669986/00006
+6310195157515669986/00008
+6310195157515669986/00009
+6310195157515669986/00010
+6310195157515669986/00011
+6310195157515669986/00012
+6310195157515669986/00015
+6310195157515669986/00016
+6310195157515669986/00017
+6310968251628953184/00001
+6310968251628953184/00002
+6310968251628953184/00010
+6310968251628953184/00011
+6310968251628953184/00014
+6310968251628953184/00018
+6311014637275749987/00001
+6311014637275749987/00002
+6311014637275749987/00003
+6311014637275749987/00007
+6311014637275749987/00012
+6311014637275749987/00013
+6311014637275749987/00014
+6311014637275749987/00018
+6311014637275749987/00025
+6311014637275749987/00026
+6311014637275749987/00027
+6311014637275749987/00028
+6311014637275749987/00029
+6311014637275749987/00030
+6311014637275749987/00033
+6311014637275749987/00034
+6311014637275749987/00035
+6311014637275749987/00036
+6311014637275749987/00038
+6311014637275749987/00039
+6311014637275749987/00040
+6311014637275749987/00041
+6311014637275749987/00042
+6311014637275749987/00043
+6311014637275749987/00044
+6311014637275749987/00046
+6311014637275749987/00047
+6311014637275749987/00048
+6311014637275749987/00049
+6311014637275749987/00050
+6311014637275749987/00051
+6311014637275749987/00052
+6311014637275749987/00053
+6311014637275749987/00054
+6311014637275749987/00055
+6311014637275749987/00056
+6311014637275749987/00057
+6311014637275749987/00058
+6311014637275749987/00060
+6311014637275749987/00063
+6311014637275749987/00064
+6311014637275749987/00066
+6311014637275749987/00068
+6311014637275749987/00069
+6311280066254641716/00006
+6311280066254641716/00010
+6311280066254641716/00013
+6311651151429016127/00001
+6311651151429016127/00003
+6311651151429016127/00004
+6311651151429016127/00014
+6311651151429016127/00018
+6311651151429016127/00019
+6312022236603390541/00008
+6312022236603390541/00009
+6312022236603390541/00010
+6312022236603390541/00012
+6312022236603390541/00013
+6312066045269810824/00004
+6312066045269810824/00006
+6312066045269810824/00007
+6312066045269810824/00008
+6312066045269810824/00010
+6312066045269810824/00012
+6312066045269810824/00015
+6312066045269810824/00016
+6312066045269810824/00021
+6312066045269810824/00022
+6312066045269810824/00023
+6312066045269810824/00026
+6312066045269810824/00027
+6312066045269810824/00028
+6313565847849574520/00006
+6313565847849574520/00013
+6313656042293295351/00001
+6313656042293295351/00003
+6313656042293295351/00004
+6313656042293295351/00007
+6313656042293295351/00008
+6313656042293295351/00009
+6313656042293295351/00012
+6313656042293295351/00014
+6313656042293295351/00016
+6313656042293295351/00018
+6313877662475262663/00001
+6313877662475262663/00005
+6313877662475262663/00012
+6313877662475262663/00013
+6313877662475262663/00015
+6313877662475262663/00016
+6313877662475262663/00017
+6313877662475262663/00018
+6313877662475262663/00028
+6313877662475262663/00030
+6313877662475262663/00033
+6313877662475262663/00034
+6313877662475262663/00039
+6313936933024013236/00002
+6313936933024013236/00004
+6313936933024013236/00006
+6313936933024013236/00008
+6313936933024013236/00009
+6313936933024013236/00011
+6313936933024013236/00014
+6314248747649637090/00009
+6314248747649637090/00013
+6314248747649637090/00014
+6314248747649637090/00015
+6314248747649637090/00017
+6314248747649637090/00018
+6314308018198387664/00001
+6314308018198387664/00002
+6314308018198387664/00005
+6314308018198387664/00006
+6314308018198387664/00008
+6314619832824012968/00002
+6314619832824012968/00004
+6314619832824012968/00007
+6314619832824012968/00010
+6314619832824012968/00011
+6314619832824012968/00012
+6314619832824012968/00015
+6314990917998387385/00003
+6314990917998387385/00004
+6314990917998387385/00006
+6314990917998387385/00007
+6315050188547072188/00003
+6315050188547072188/00011
+6315050188547072188/00014
+6315405811839181004/00002
+6315405811839181004/00003
+6315405811839181004/00004
+6315405811839181004/00005
+6315405811839181004/00006
+6315405811839181004/00007
+6315405811839181004/00008
+6315405811839181004/00009
+6315405811839181004/00011
+6315405811839181004/00012
+6315405811839181004/00018
+6315405811839181004/00019
+6315405811839181004/00021
+6315405811839181004/00023
+6315405811839181004/00026
+6315405811839181004/00027
+6315405811839181004/00029
+6315405811839181004/00030
+6315405811839181004/00031
+6315405811839181004/00033
+6315405811839181004/00034
+6315405811839181004/00035
+6315405811839181004/00036
+6315405811839181004/00037
+6315405811839181004/00041
+6315405811839181004/00042
+6315405811839181004/00043
+6315405811839181004/00044
+6315405811839181004/00045
+6315405811839181004/00046
+6315405811839181004/00049
+6315405811839181004/00050
+6315405811839181004/00051
+6315405811839181004/00052
+6315405811839181004/00053
+6315421273721446605/00002
+6315421273721446605/00003
+6315421273721446605/00006
+6316024287129869379/00001
+6316024287129869379/00002
+6316024287129869379/00003
+6316024287129869379/00007
+6316024287129869379/00010
+6316024287129869379/00011
+6316024287129869379/00012
+6316024287129869379/00013
+6316024287129869379/00014
+6316024287129869379/00016
+6316024287129869379/00017
+6316024287129869379/00018
+6316024287129869379/00023
+6316024287129869379/00027
+6316024287129869379/00028
+6316024287129869379/00029
+6316024287129869379/00032
+6316024287129869379/00035
+6316024287129869379/00038
+6316024287129869379/00040
+6316024287129869379/00042
+6316024287129869379/00045
+6316024287129869379/00047
+6316024287129869379/00048
+6316024287129869379/00049
+6316163444070195447/00001
+6316163444070195447/00007
+6316163444070195447/00008
+6318761040290818803/00009
+6318761040290818803/00012
+6318761040290818803/00013
+6318761040290818803/00019
+6318761040290818803/00021
+6318761040290818803/00022
+6318761040290818803/00023
+6318761040290818803/00024
+6318761040290818803/00026
+6321358636511442057/00002
+6321358636511442057/00003
+6321358636511442057/00004
+6321358636511442057/00005
+6321358636511442057/00006
+6321358636511442057/00008
+6321358636511442057/00010
+6321358636511442057/00015
+6321358636511442057/00017
+6322100806860254619/00006
+6322100806860254619/00008
+6322100806860254619/00009
+6323198600501050831/00003
+6323198600501050831/00006
+6323198600501050831/00007
+6323198600501050831/00008
+6323198600501050831/00013
+6323198600501050831/00016
+6323198600501050831/00017
+6323198600501050831/00018
+6323198600501050831/00019
+6323198600501050831/00020
+6323198600501050831/00022
+6323198600501050831/00023
+6323198600501050831/00024
+6323198600501050831/00025
+6323198600501050831/00027
+6323198600501050831/00029
+6323198600501050831/00030
+6323198600501050831/00032
+6323198600501050831/00033
+6323198600501050831/00037
+6323221793324446979/00001
+6323221793324446979/00002
+6323221793324446979/00004
+6323221793324446979/00005
+6323221793324446979/00007
+6323221793324446979/00008
+6323221793324446979/00011
+6323221793324446979/00012
+6323221793324446979/00013
+6323221793324446979/00015
+6323221793324446979/00016
+6323221793324446979/00017
+6323221793324446979/00018
+6323221793324446979/00022
+6323221793324446979/00025
+6323221793324446979/00026
+6323221793324446979/00028
+6323221793324446979/00029
+6323221793324446979/00032
+6323221793324446979/00033
+6323221793324446979/00035
+6323221793324446979/00039
+6323221793324446979/00041
+6323221793324446979/00042
+6323221793324446979/00043
+6323221793324446979/00045
+6323817075791736335/00002
+6323817075791736335/00010
+6323817075791736335/00013
+6323817075791736335/00015
+6323817075791736335/00020
+6323817075791736335/00024
+6323817075791736335/00026
+6323817075791736335/00028
+6323817075791736335/00029
+6323817075791736335/00030
+6323817075791736335/00032
+6323817075791736335/00033
+6323817075791736335/00034
+6323817075791736335/00041
+6323817075791736335/00042
+6323817075791736335/00046
+6323817075791736335/00049
+6323817075791736335/00050
+6323817075791736335/00051
+6323817075791736335/00053
+6323817075791736335/00054
+6323817075791736335/00055
+6323817075791736335/00056
+6323817075791736335/00063
+6323817075791736335/00065
+6323817075791736335/00066
+6323817075791736335/00067
+6323817075791736335/00072
+6323817075791736335/00073
+6323817075791736335/00074
+6323817075791736335/00075
+6323817075791736335/00085
+6323817075791736335/00106
+6323956232732063947/00005
+6323956232732063947/00011
+6323956232732063947/00017
+6323956232732063947/00019
+6323956232732063947/00020
+6323956232732063947/00022
+6323956232732063947/00023
+6323956232732126743/00004
+6323956232732126743/00005
+6323956232732126743/00006
+6323956232732126743/00007
+6323956232732126743/00008
+6323956232732126743/00009
+6323956232732126743/00010
+6323956232732126743/00013
+6323956232732126743/00014
+6323956232732126743/00016
+6323956232732126743/00017
+6323956232732126743/00018
+6323956232732126743/00019
+6323956232732126743/00020
+6323956232732126743/00025
+6323956232732126743/00027
+6323956232732126743/00028
+6323956232732126743/00029
+6323956232732126743/00030
+6323956232732126743/00032
+6323956232732126743/00034
+6324230681142278360/00002
+6324230681142278360/00006
+6324230681142278360/00007
+6324230681142278360/00009
+6324230681142278360/00010
+6324230681142278360/00013
+6324230681142278360/00016
+6324698403080812792/00002
+6324698403080812792/00005
+6324698403080812792/00010
+6324698403080812792/00011
+6324698403080812792/00015
+6324698403080812792/00016
+6324698403080812792/00017
+6324698403080812792/00021
+6324698403080812792/00022
+6324698403080812792/00023
+6324698403080812792/00024
+6324698403080812792/00027
+6324698403080875597/00006
+6324698403080875597/00007
+6324713864963081921/00001
+6324713864963081921/00006
+6324713864963081921/00011
+6324713864963081921/00013
+6324713864963081921/00016
+6324713864963081921/00017
+6324713864963081921/00019
+6324713864963081921/00021
+6324713864963081921/00024
+6324713864963081921/00026
+6324764116080445123/00001
+6324764116080445123/00004
+6324764116080445123/00006
+6324764116080445123/00007
+6324764116080445123/00008
+6324764116080445123/00010
+6324764116080445123/00011
+6324764116080445123/00012
+6324764116080445123/00013
+6324764116080445123/00014
+6324764116080445123/00017
+6324764116080445123/00018
+6324764116080445123/00019
+6324764116080445123/00020
+6325119739372550419/00005
+6325119739372550419/00015
+6325119739372550419/00016
+6325119739372550419/00017
+6325119739372550419/00021
+6325119739372550419/00022
+6325119739372550419/00023
+6325119739372550419/00024
+6325119739372550419/00026
+6325119739372550419/00027
+6325440573560032726/00001
+6325440573560032726/00002
+6325440573560032726/00003
+6325440573560032726/00005
+6325440573560032726/00006
+6325440573560032726/00007
+6325440573560032726/00008
+6325440573560032726/00011
+6325440573560032726/00012
+6325440573560032726/00015
+6325440573560032726/00016
+6325440573560032726/00018
+6325440573560032726/00021
+6325440573560032726/00022
+6325440573560032726/00025
+6325440573560032726/00026
+6325440573560032726/00028
+6325440573560032726/00029
+6325440573560032726/00030
+6325440573560032726/00031
+6325440573560032726/00032
+6325440573560032726/00034
+6325440573560032726/00035
+6325440573560032726/00036
+6325456035311830751/00002
+6325456035311830751/00005
+6325456035311830751/00006
+6325456035311830751/00007
+6325456035311830751/00013
+6325456035311830751/00017
+6325796196721673967/00005
+6325796196721673967/00007
+6325796196721673967/00009
+6325796196721673967/00010
+6325796196721673967/00011
+6325819389545137915/00001
+6325819389545137915/00002
+6325819389545137915/00003
+6325819389545137915/00004
+6325819389545137915/00005
+6325819389545137915/00008
+6325819389545137915/00010
+6325819389545137915/00011
+6325819389545137915/00012
+6325819389545137915/00013
+6325894121976022773/00003
+6325894121976022773/00004
+6325894121976022773/00005
+6325894121976022773/00006
+6325894121976022773/00008
+6325894121976022773/00010
+6325894121976022773/00011
+6325894121976022773/00013
+6325894121976022773/00014
+6325894121976022773/00016
+6326360555424366722/00003
+6326360555424366722/00004
+6326360555424366722/00006
+6326360555424366722/00007
+6326360555424366722/00008
+6326360555424366722/00009
+6326360555424366722/00012
+6326360555424366722/00013
+6326360555424366722/00014
+6326360555424366722/00016
+6326360555424366722/00017
+6326360555424366722/00018
+6326360555424366722/00019
+6326360555424366722/00020
+6326360555424366722/00021
+6326360555424366722/00022
+6326360555424366722/00024
+6326360555424366722/00025
+6326360555424366722/00026
+6326360555424366722/00028
+6326360555424366722/00029
+6326360555424366722/00030
+6326360555424366722/00033
+6326360555424366722/00034
+6326360555424366722/00038
+6326360555424366722/00039
+6326360555424366722/00040
+6326360555424366722/00041
+6326360555424366722/00042
+6326360555424366722/00044
+6326360555424366722/00045
+6326360555424366722/00047
+6326360555424366722/00048
+6326360555424366722/00050
+6326360555424366722/00051
+6326360555424366722/00052
+6326360555424366722/00054
+6326414672012357313/00001
+6326414672012357313/00002
+6326414672012357313/00004
+6326414672012357313/00005
+6326414672012357313/00006
+6326414672012357313/00011
+6326414672012357313/00013
+6326414672012357313/00014
+6326414672012357313/00015
+6326414672012357313/00016
+6326414672012357313/00018
+6326414672012357313/00019
+6326414672012357313/00021
+6326414672012357313/00022
+6326414672012357313/00023
+6326414672012357313/00024
+6326414672012357313/00025
+6326414672012357313/00028
+6326414672012357313/00030
+6326414672012357313/00031
+6326414672012357313/00035
+6326414672012357313/00037
+6326414672012357313/00040
+6326414672012357313/00041
+6326414672012357313/00042
+6326414672012357313/00043
+6326414672012357313/00046
+6326414672012357313/00047
+6326414672012357313/00049
+6326414672012357313/00051
+6326414672012357313/00052
+6326414672012357313/00053
+6326414672012357313/00056
+6326414672012357313/00058
+6326414672012357313/00060
+6326414672012357313/00061
+6326414672012357313/00064
+6326414672012357313/00069
+6326414672012357313/00072
+6326414672012357313/00073
+6326414672012357313/00074
+6326414672012357313/00075
+6326414672012357313/00080
+6326414672012357313/00083
+6326414672012357313/00086
+6326414672012357313/00087
+6326461057659161695/00005
+6326461057659161695/00009
+6326461057659161695/00010
+6326461057659161695/00011
+6326461057659161695/00013
+6326461057659161695/00015
+6326461057659161695/00016
+6326461057659161695/00019
+6326538367070482119/00001
+6326538367070482119/00002
+6326538367070482119/00004
+6326553828952690654/00001
+6326553828952690654/00002
+6326553828952690654/00003
+6326553828952690654/00006
+6326553828952690654/00007
+6326553828952690654/00011
+6326553828952690654/00012
+6326553828952690654/00015
+6326553828952690654/00016
+6326553828952690654/00018
+6326553828952690654/00020
+6326553828952690654/00023
+6326866932068565154/00002
+6326866932068565154/00005
+6326866932068565154/00008
+6326866932068565154/00012
+6326866932068565154/00015
+6326866932068565154/00016
+6326990627126693682/00003
+6326990627126693682/00004
+6326990627126693682/00005
+6326990627126693682/00006
+6327199362537275576/00005
+6327199362537275576/00007
+6327199362537275576/00008
+6327199362537275576/00017
+6327295999301439627/00005
+6327295999301439627/00009
+6327295999301439627/00011
+6327295999301439627/00014
+6327295999301439627/00018
+6327295999301499598/00001
+6327295999301499598/00003
+6327295999301499598/00004
+6327295999301499598/00005
+6327295999301499598/00007
+6327295999301499598/00008
+6327295999301499598/00010
+6327570447711650000/00004
+6327570447711650000/00005
+6327609102417316299/00001
+6327609102417316299/00002
+6327609102417316299/00004
+6327609102417316299/00006
+6327609102417316299/00010
+6327609102417316299/00011
+6327609102417316299/00012
+6327713470253076639/00001
+6327713470253076639/00002
+6327713470253076639/00004
+6327713470253076639/00007
+6327713470253076639/00009
+6327713470253076639/00011
+6327713470253076639/00016
+6327713470253076639/00019
+6327713470253076639/00020
+6327713470253076639/00021
+6327713470253076639/00022
+6327713470253076639/00023
+6327713470253076639/00024
+6327713470253076639/00025
+6327713470253076639/00026
+6327713470253076639/00027
+6327713470253076639/00029
+6327713470253076639/00030
+6327713470253076639/00031
+6327713470253076639/00033
+6327713470253076639/00038
+6327713470253076639/00039
+6327713470253076639/00040
+6327713470253076639/00042
+6327713470253076639/00048
+6327713470253076639/00050
+6327713470253076639/00051
+6327713470253076639/00052
+6327713470253076639/00054
+6327713470253076639/00055
+6327713470253076639/00058
+6327713470253076639/00062
+6327740528416575363/00001
+6327740528416575363/00002
+6327740528416575363/00003
+6327740528416575363/00004
+6327740528416575363/00007
+6327740528416575363/00008
+6327740528416575363/00009
+6327740528416575363/00010
+6327740528416575363/00011
+6327740528416575363/00012
+6327740528416575363/00013
+6327740528416575363/00015
+6327740528416575363/00017
+6327740528416575363/00019
+6327740528416575363/00020
+6327740528416575363/00021
+6327740528416575363/00022
+6327740528416575363/00023
+6327740528416575363/00024
+6327740528416575363/00025
+6327740528416575363/00026
+6327740528416575363/00027
+6327740528416575363/00028
+6327740528416575363/00036
+6327740528416575363/00037
+6327740528416575363/00038
+6327740528416575363/00039
+6327941532886024424/00001
+6327941532886024424/00002
+6327941532886024424/00006
+6327980187591690710/00003
+6328038169780654524/00001
+6328038169780654524/00004
+6328038169780654524/00005
+6328038169780654524/00008
+6328038169780654524/00009
+6328038169780654524/00010
+6328038169780654524/00012
+6328038169780654524/00013
+6328038169780654524/00014
+6328111613590949805/00003
+6328111613590949805/00004
+6328111613590949805/00009
+6328111613590949805/00010
+6328111613590949805/00012
+6328111613590949805/00013
+6328111613590949805/00015
+6328111613590949805/00016
+6328111613590949805/00017
+6328111613590949805/00018
+6328111613590949805/00019
+6328111613590949805/00021
+6328111613590949805/00023
+6328111613590949805/00024
+6328111613590949805/00025
+6328111613590949805/00026
+6328111613590949805/00027
+6328111613590949805/00029
+6328111613590949805/00030
+6328312618060398848/00010
+6328312618060398848/00011
+6328351272766065122/00002
+6328351272766065122/00003
+6328351272766065122/00006
+6328351272766065122/00007
+6328393792942295524/00001
+6328393792942295524/00002
+6328393792942295524/00003
+6328393792942295524/00004
+6328393792942295524/00005
+6328393792942295524/00006
+6328393792942295524/00010
+6328512334039666732/00003
+6328512334039666732/00005
+6328512334039666732/00007
+6328512334039666732/00008
+6328512334039666732/00010
+6328512334039666732/00012
+6328512334039666732/00013
+6328656644940810739/00006
+6328764878116731644/00005
+6328764878116731644/00006
+6328764878116731644/00007
+6328764878116731644/00008
+6328764878116731644/00010
+6328764878116731644/00013
+6328764878116731644/00014
+6328764878116731644/00019
+6328764878116731644/00021
+6328764878116731644/00023
+6328764878116731644/00025
+6328764878116731644/00028
+6328764878116731644/00029
+6328764878116731644/00030
+6328764878116731644/00031
+6328764878116731644/00032
+6328962017115556355/00001
+6328962017115556355/00002
+6328962017115556355/00003
+6328962017115556355/00004
+6328962017115556355/00007
+6328962017115556355/00009
+6328962017115556355/00010
+6328962017115556355/00011
+6329054788409218032/00003
+6329054788409218032/00004
+6329054788409218032/00008
+6329054788409218032/00016
+6329054788409218032/00017
+6329062519350282760/00002
+6329062519350282760/00006
+6329062519350282760/00009
+6329062519350282760/00011
+6329062519350282760/00013
+6329062519350282760/00014
+6329062519350282760/00016
+6329062519350282760/00017
+6329151425173313518/00001
+6329151425173313518/00002
+6329151425173313518/00003
+6329151425173313518/00004
+6329151425173313518/00005
+6329151425173313518/00006
+6329151425173313518/00007
+6329151425173313518/00010
+6329151425173313518/00011
+6329151425173313518/00013
+6329151425173313518/00015
+6329151425173313518/00016
+6329151425173313518/00017
+6329151425173313518/00018
+6329151425173313518/00023
+6329151425173313518/00024
+6329151425173313518/00025
+6329151425173313518/00026
+6329151425173313518/00029
+6329151425173313518/00030
+6329151425173313518/00031
+6329151425173313518/00034
+6329151425173313518/00036
+6329151425173313518/00037
+6329151425173313518/00039
+6329151425173313518/00040
+6329151425173313518/00041
+6329151425173313518/00042
+6329151425173313518/00043
+6329151425173313518/00044
+6329151425173313518/00046
+6329151425173313518/00047
+6329151425173313518/00049
+6329151425173313518/00051
+6329151425173313518/00054
+6329151425173313518/00056
+6329151425173313518/00057
+6329151425173313518/00060
+6329151425173313518/00061
+6329151425173313518/00062
+6329151425173313518/00064
+6329151425173313518/00066
+6329151425173313518/00067
+6329151425173313518/00068
+6329151425173313518/00071
+6329151425173313518/00072
+6329151425173313518/00073
+6329151425173313518/00074
+6329151425173313518/00075
+6329151425173313518/00076
+6329151425173313518/00077
+6329151425173313518/00078
+6329151425173313518/00079
+6329151425173313518/00080
+6329151425173313518/00082
+6329151425173313518/00085
+6329151425173313518/00086
+6329151425173313518/00087
+6329151425173313518/00090
+6329151425173313518/00092
+6329151425173313518/00095
+6329151425173313518/00096
+6329151425173313518/00098
+6329151425173313518/00099
+6329151425173313518/00100
+6329151425173313518/00101
+6329151425173313518/00102
+6329151425173313518/00103
+6329151425173313518/00104
+6329151425173313518/00105
+6329151425173313518/00107
+6329151425173313518/00108
+6329151425173313518/00111
+6329151425173313518/00112
+6329151425173313518/00113
+6329151425173313518/00114
+6329151425173313518/00115
+6329151425173313518/00116
+6329151425173313518/00117
+6329151425173313518/00118
+6329151425173313518/00119
+6329151425173313518/00120
+6329835613463566698/00001
+6329835613463566698/00002
+6329835613463566698/00005
+6329835613463566698/00007
+6329835613463566698/00011
+6329835613463566698/00015
+6329835613463566698/00017
+6329835613463566698/00018
+6329835613463566698/00020
+6329835613463566698/00021
+6329835613463566698/00022
+6329835613463566698/00023
+6329835613463566698/00024
+6329835613463566698/00025
+6329835613463566698/00026
+6329835613463566698/00027
+6329893595522062514/00003
+6329893595522062514/00004
+6329893595522062514/00005
+6329893595522062514/00007
+6329893595522062514/00009
+6329893595522062514/00010
+6329893595522122781/00002
+6329893595522122781/00005
+6329893595522122781/00006
+6329893595522122781/00007
+6329893595522122781/00008
+6329893595522122781/00010
+6329893595522122781/00011

data/LRS2_CTC2_test.txt

@@ -0,0 +1,279 @@
+6330311066473698535/00011
+6331559613336179781/00021
+6331559613336179781/00036
+6331733559511729306/00011
+6331733559511729306/00025
+6331733559511729306/00031
+6332062124509813446/00016
+6332491191742745853/00014
+6332804294858562278/00020
+6333175380032936690/00012
+6334934169140712754/00002
+6335305254315087182/00028
+6335676339489461610/00002
+6335676339489461610/00011
+6335676339489461610/00070
+6336047424663836038/00006
+6336047424663836038/00008
+6336739343895160063/00006
+6336739343895160063/00027
+6337160680186960682/00054
+6337160680186960682/00078
+6337531765361335111/00018
+6337531765361335111/00019
+6337531765361335111/00022
+6337902850535709539/00015
+6337902850535709539/00038
+6337902850535709539/00077
+6338130913429528164/00037
+6338273935710083967/00003
+6338273935710083967/00076
+6338645020884458400/00032
+6338645020884458400/00046
+6338807370648247218/00020
+6339077953587836416/00025
+6339077953587836416/00029
+6339077953587836416/00031
+6339356267468615354/00006
+6339758276407584924/00036
+6339758276407584924/00089
+6340299442417279404/00006
+6340500446756333781/00059
+6340871531930708209/00057
+6340871531930708209/00073
+6340871531930708209/00102
+6340871531930708209/00106
+6341242617105082637/00022
+6341404966868871455/00002
+6342112347982522696/00020
+6342440912980576694/00002
+6343252661930009508/00006
+6343252661930009508/00061
+6343252661930009508/00111
+6343979370266033402/00001
+6344002563089494087/00016
+6344350455440407821/00030
+6344350455440407821/00032
+6344709944203120665/00030
+6344737002497020519/00001
+6347195441777342774/00054
+6347195441777342774/00074
+6347350060599908703/00007
+6347524006775395501/00006
+6348038114360790454/00012
+6348409199535164855/00011
+6348409199535164855/00054
+6348463316123031920/00004
+6348463316123031920/00014
+6348714571709909926/00001
+6348780284709539256/00026
+6348834401297406331/00023
+6348834401297406331/00046
+6349108849707618270/00007
+6349174562707247076/00008
+6349213217412979095/00010
+6349559821273762790/00002
+6349793037997935601/00067
+6349793037997935601/00138
+6349847154585871175/00027
+6349847154585871175/00037
+6350152526760616781/00013
+6350222105230808621/00007
+6350222105230808621/00012
+6350295549171504559/00016
+6350523611934991188/00013
+6350523611934991188/00021
+6350666634345878987/00013
+6350921755403330389/00027
+6351037719520253414/00001
+6351265782283739990/00001
+6351431997518095202/00017
+6351714176869448803/00004
+6351714176869448803/00010
+6351772158927869467/00029
+6351810813633601326/00001
+6351810813633601326/00007
+6351810813633601326/00014
+6351810813633601326/00020
+6352157417494386368/00030
+6352157417494386368/00043
+6352533656629519062/00013
+6352815835980800496/00002
+6352893145392128503/00013
+6352893145392128503/00020
+6353233306802036640/00005
+6353233306802036640/00019
+6353233306802036640/00037
+6353264230566502930/00014
+6353604391976411066/00001
+6353975477150785494/00019
+6354304042148929518/00013
+6354369755148493407/00023
+6354755013715009552/00005
+6354988230439182363/00053
+6354988230439182363/00085
+6354988230439182363/00181
+6355544858200683461/00002
+6355568051024147448/00012
+6356201988197034394/00044
+6356232911961499649/00017
+6356232911961499649/00026
+6356530553195178439/00014
+6356573073371408843/00033
+6356573073371408843/00045
+6356603997135874072/00027
+6356619459018205648/00002
+6356878445546153116/00004
+6357006006074844331/00008
+6357006006074844331/00013
+6357353898425821669/00020
+6357353898425821669/00043
+6357701790776745251/00011
+6357701790776745251/00017
+6357714675678689620/00010
+6357714675678689620/00025
+6357798427540961623/00008
+6358088337833374405/00011
+6358428499243281970/00026
+6358757064241425994/00003
+6359128149415800422/00006
+6359541754766405254/00018
+6359541754766405254/00020
+6359564947589739760/00043
+6359580409472005362/00001
+6359951494646443684/00007
+6359982418410974886/00001
+6359982418410974886/00003
+6360322579951237696/00016
+6360322579951237696/00027
+6360327733781577947/00020
+6360393446781206759/00013
+6360709126877459881/00011
+6360740050641926958/00002
+6360740050641926958/00004
+6361028672444286629/00023
+6361028672444286629/00026
+6361354660462048727/00012
+6362143216457594387/00021
+6362162543810362236/00006
+6362460185044046481/00014
+6362546513886688816/00002
+6362546513886688816/00008
+6362913733590438579/00002
+6362913733590438579/00082
+6362913733590438579/00105
+6362913733590438579/00132
+6362913733590438579/00147
+6362913733590438579/00156
+6362913733590438579/00199
+6362913733590438579/00213
+6362925330002196038/00013
+6362925330002196038/00014
+6362958830877522951/00003
+6363210086333922442/00011
+6363306723098082453/00001
+6363654615448994597/00013
+6363952256682671319/00004
+6363952256682671319/00010
+6363956122153173818/00006
+6364319476386415444/00005
+6364319476386415444/00009
+6364760140030989000/00017
+6364760140030989000/00021
+6364791063795516278/00005
+6364791063795580193/00005
+6364791063795580193/00006
+6365141533126941637/00012
+6365141533126941637/00013
+6365141533126941637/00056
+6366944130901006716/00005
+6367373198133943465/00025
+6367373198133943465/00086
+6367373198133943465/00138
+6367373198133943465/00143
+6367373198133943465/00144
+6367373198133943465/00163
+6367396390957341434/00014
+6367813861908922495/00003
+6367813861908922495/00004
+6368111503012125648/00018
+6368111503012125648/00025
+6368494184598133861/00007
+6368494184598133861/00017
+6368525108362665063/00017
+6368525108362665063/00053
+6368525108362665063/00069
+6369259547770281088/00021
+6369599709180191149/00017
+6369912812296002056/00019
+6369912812296002056/00022
+6369912812296002056/00024
+6369986256236764320/00008
+6369986256236764320/00041
+6370331571607430336/00009
+6370728426585516325/00008
+6370728426585516325/00018
+6371114973642156346/00011
+6371114973642221152/00004
+6371114973642221152/00010
+6371470597064737331/00017
+6371470597064737331/00032
+6373112133434795034/00002
+6373202327748070121/00011
+6373318291865072119/00019
+6373627529510317190/00004
+6374083655167624227/00010
+6374083655167624227/00053
+6374454740211592999/00010
+6375480378401815497/00011
+6375516456127164915/00004
+6375915888085690147/00047
+6375923619026758902/00014
+6376623269199281113/00006
+6376623269199281113/00008
+6376623269199281113/00012
+6377400228783189968/00015
+6377779044898631026/00001
+6377794506780964609/00012
+6378324076248495598/00012
+6378795663657663776/00006
+6378907762304088259/00008
+6379537834006412580/00020
+6380036479839881698/00007
+6380036479839881698/00029
+6380036479839881698/00049
+6381381663466492945/00031
+6381381663466492945/00032
+6381766922032944158/00007
+6382189546814897943/00006
+6382247528873432347/00020
+6382618614178237455/00003
+6382618614178237455/00013
+6382618614178237455/00020
+6382618614178237455/00024
+6382618614178237455/00035
+6382618614178237455/00045
+6382866004163990600/00003
+6382877600575782419/00001
+6382880177556067401/00009
+6383716407688597209/00025
+6383990856098877828/00004
+6384361941273252259/00010
+6384829663342218937/00026
+6385158228209864505/00005
+6385216210398859008/00005
+6386314003909220420/00006
+6386700550965861901/00019
+6387319026256487668/00016
+6387701707842623991/00004
+6387705573313124513/00008
+6388126909604862142/00032
+6388726057542659435/00015
+6388772443189516866/00002
+6388911600129842790/00013
+6389970739065104229/00029
+6390299304063246834/00003
+6390672966217932513/00002
+6391420290527506887/00024
+6392282290463747809/00018
+6392568335285725796/00013

data/LRS2_CTC2_val.txt

@@ -0,0 +1,189 @@
+6300370419826092098/00001
+6300370419826092098/00003
+6300370419826092098/00012
+6300370419826092098/00020
+6300370419826092098/00024
+6300370419826092098/00025
+6301320037095305408/00010
+6302978323968228875/00005
+6302978323968228875/00011
+6302978323968228875/00015
+6302978323968228875/00020
+6303167732026041278/00014
+6306811582279909115/00011
+6306811582279909115/00012
+6306870852828565379/00008
+6306870852828565379/00026
+6306870852828565379/00028
+6306870852828565379/00029
+6308177381880006979/00001
+6308177381880006979/00002
+6308177381880006979/00013
+6308177381880006979/00028
+6309468449049188125/00006
+6310166810731517953/00009
+6310166810731517953/00016
+6310166810731517953/00026
+6310195157515669986/00006
+6310195157515669986/00011
+6311014637275749987/00007
+6311014637275749987/00012
+6311014637275749987/00033
+6311014637275749987/00038
+6311014637275749987/00055
+6311014637275749987/00057
+6311651151429016127/00004
+6312066045269810824/00010
+6312066045269810824/00015
+6312066045269810824/00026
+6313656042293295351/00009
+6313656042293295351/00018
+6313877662475262663/00033
+6314248747649637090/00013
+6314248747649637090/00017
+6314308018198387664/00001
+6314308018198387664/00002
+6314308018198387664/00005
+6314308018198387664/00006
+6314619832824012968/00007
+6314619832824012968/00015
+6314990917998387385/00004
+6314990917998387385/00007
+6315050188547072188/00003
+6315050188547072188/00014
+6315405811839181004/00003
+6315405811839181004/00021
+6315405811839181004/00033
+6315405811839181004/00034
+6315405811839181004/00051
+6315405811839181004/00052
+6316024287129869379/00010
+6316024287129869379/00014
+6316024287129869379/00017
+6316024287129869379/00023
+6316024287129869379/00027
+6316024287129869379/00047
+6318761040290818803/00022
+6321358636511442057/00003
+6322100806860254619/00006
+6323198600501050831/00003
+6323198600501050831/00029
+6323221793324446979/00004
+6323221793324446979/00018
+6323817075791736335/00002
+6323817075791736335/00010
+6323817075791736335/00026
+6323817075791736335/00034
+6323817075791736335/00041
+6323817075791736335/00053
+6323817075791736335/00054
+6323817075791736335/00075
+6323956232732126743/00009
+6323956232732126743/00010
+6323956232732126743/00016
+6323956232732126743/00018
+6323956232732126743/00029
+6323956232732126743/00030
+6324230681142278360/00009
+6324230681142278360/00016
+6324698403080812792/00002
+6324698403080812792/00015
+6324698403080812792/00017
+6324698403080812792/00022
+6324698403080875597/00006
+6324713864963081921/00016
+6324713864963081921/00026
+6324764116080445123/00006
+6324764116080445123/00013
+6325119739372550419/00015
+6325119739372550419/00017
+6325119739372550419/00022
+6325440573560032726/00008
+6325440573560032726/00015
+6325440573560032726/00032
+6325796196721673967/00007
+6325796196721673967/00011
+6325819389545137915/00004
+6325819389545137915/00005
+6325819389545137915/00013
+6325894121976022773/00011
+6326360555424366722/00003
+6326360555424366722/00014
+6326360555424366722/00022
+6326360555424366722/00030
+6326360555424366722/00039
+6326360555424366722/00048
+6326414672012357313/00001
+6326414672012357313/00004
+6326414672012357313/00006
+6326414672012357313/00016
+6326414672012357313/00024
+6326414672012357313/00030
+6326414672012357313/00031
+6326414672012357313/00035
+6326414672012357313/00043
+6326414672012357313/00047
+6326414672012357313/00056
+6326414672012357313/00058
+6326414672012357313/00064
+6326461057659161695/00009
+6326461057659161695/00010
+6326461057659161695/00015
+6326461057659161695/00016
+6326538367070482119/00001
+6326538367070482119/00004
+6326553828952690654/00012
+6326553828952690654/00015
+6326553828952690654/00018
+6326553828952690654/00020
+6327295999301439627/00018
+6327570447711650000/00004
+6327570447711650000/00005
+6327609102417316299/00011
+6327740528416575363/00008
+6327740528416575363/00011
+6327740528416575363/00023
+6328038169780654524/00009
+6328038169780654524/00010
+6328111613590949805/00003
+6328111613590949805/00004
+6328111613590949805/00018
+6328111613590949805/00027
+6328111613590949805/00029
+6328351272766065122/00006
+6328512334039666732/00012
+6328764878116731644/00007
+6328962017115556355/00009
+6328962017115556355/00011
+6329054788409218032/00003
+6329054788409218032/00008
+6329054788409218032/00016
+6329054788409218032/00017
+6329151425173313518/00001
+6329151425173313518/00002
+6329151425173313518/00017
+6329151425173313518/00024
+6329151425173313518/00025
+6329151425173313518/00026
+6329151425173313518/00031
+6329151425173313518/00039
+6329151425173313518/00040
+6329151425173313518/00046
+6329151425173313518/00047
+6329151425173313518/00051
+6329151425173313518/00054
+6329151425173313518/00056
+6329151425173313518/00061
+6329151425173313518/00080
+6329151425173313518/00086
+6329151425173313518/00087
+6329151425173313518/00101
+6329151425173313518/00107
+6329151425173313518/00112
+6329151425173313518/00113
+6329151425173313518/00114
+6329151425173313518/00115
+6329151425173313518/00116
+6329835613463566698/00001
+6329835613463566698/00015
+6329893595522062514/00010

data/phonemes_overlap_val.txt

@@ -0,0 +1,3570 @@
+lip/GRID/s4/lgaz6a.mpg
+lip/GRID/s4/lwie4a.mpg
+lip/GRID/s4/lbwr2a.mpg
+lip/GRID/s4/brif4a.mpg
+lip/GRID/s4/bbws5n.mpg
+lip/GRID/s4/bbwz9n.mpg
+lip/GRID/s4/prbp8a.mpg
+lip/GRID/s4/srbu6a.mpg
+lip/GRID/s4/bwam6s.mpg
+lip/GRID/s4/lwiq9n.mpg
+lip/GRID/s4/prwd1n.mpg
+lip/GRID/s4/lwae6s.mpg
+lip/GRID/s4/bgahza.mpg
+lip/GRID/s4/priv1n.mpg
+lip/GRID/s4/bramzs.mpg
+lip/GRID/s4/sran5n.mpg
+lip/GRID/s4/lbiqza.mpg
+lip/GRID/s4/prac5p.mpg
+lip/GRID/s4/bgwu5p.mpg
+lip/GRID/s4/bbil1p.mpg
+lip/GRID/s4/pwiv8s.mpg
+lip/GRID/s4/bbwgza.mpg
+lip/GRID/s4/pwbd6a.mpg
+lip/GRID/s4/srwi2a.mpg
+lip/GRID/s4/brbm3n.mpg
+lip/GRID/s4/srig7n.mpg
+lip/GRID/s4/pgaq3n.mpg
+lip/GRID/s4/lwbfzs.mpg
+lip/GRID/s4/pbbo9n.mpg
+lip/GRID/s4/pbai4a.mpg
+lip/GRID/s4/lgaf4a.mpg
+lip/GRID/s4/prap2s.mpg
+lip/GRID/s4/swao1n.mpg
+lip/GRID/s4/pwwk2s.mpg
+lip/GRID/s4/bwbt3n.mpg
+lip/GRID/s4/sria5p.mpg
+lip/GRID/s4/bbwm4a.mpg
+lip/GRID/s4/pgix3n.mpg
+lip/GRID/s4/pgayza.mpg
+lip/GRID/s4/bwbn1p.mpg
+lip/GRID/s4/lrbk8s.mpg
+lip/GRID/s4/lgal7p.mpg
+lip/GRID/s4/sbba7p.mpg
+lip/GRID/s4/lbaj9p.mpg
+lip/GRID/s4/lbwy4s.mpg
+lip/GRID/s4/bwigza.mpg
+lip/GRID/s4/sbim7p.mpg
+lip/GRID/s4/sgbp4a.mpg
+lip/GRID/s4/swab6a.mpg
+lip/GRID/s4/sbiaza.mpg
+lip/GRID/s4/lbaj8s.mpg
+lip/GRID/s4/bbbz8a.mpg
+lip/GRID/s4/lwbsza.mpg
+lip/GRID/s4/brwt4a.mpg
+lip/GRID/s4/lwie1n.mpg
+lip/GRID/s4/pbio1n.mpg
+lip/GRID/s4/bbar7n.mpg
+lip/GRID/s4/swau6s.mpg
+lip/GRID/s4/bbaz1n.mpg
+lip/GRID/s4/lwwf3n.mpg
+lip/GRID/s4/pbbi6s.mpg
+lip/GRID/s4/lrwzzs.mpg
+lip/GRID/s4/pwwx9n.mpg
+lip/GRID/s4/srbh6s.mpg
+lip/GRID/s4/srbo2a.mpg
+lip/GRID/s4/lbad4s.mpg
+lip/GRID/s4/lrbr1n.mpg
+lip/GRID/s4/sgab9n.mpg
+lip/GRID/s4/lbaq4a.mpg
+lip/GRID/s4/prai8s.mpg
+lip/GRID/s4/srbh8a.mpg
+lip/GRID/s4/lwal2a.mpg
+lip/GRID/s4/sbwh3n.mpg
+lip/GRID/s4/priv3p.mpg
+lip/GRID/s4/bwwn6a.mpg
+lip/GRID/s4/lbbq6s.mpg
+lip/GRID/s4/lrikzs.mpg
+lip/GRID/s4/pbwc7p.mpg
+lip/GRID/s4/pgbk4s.mpg
+lip/GRID/s4/pbiu7p.mpg
+lip/GRID/s4/pwweza.mpg
+lip/GRID/s4/lbix3p.mpg
+lip/GRID/s4/sgwx1p.mpg
+lip/GRID/s4/pgix4s.mpg
+lip/GRID/s4/bgit3p.mpg
+lip/GRID/s4/lgal8a.mpg
+lip/GRID/s4/bbal3n.mpg
+lip/GRID/s4/sria4s.mpg
+lip/GRID/s4/srwb5n.mpg
+lip/GRID/s4/lbwe1n.mpg
+lip/GRID/s4/lrwe7n.mpg
+lip/GRID/s4/brwnza.mpg
+lip/GRID/s4/lwiy5p.mpg
+lip/GRID/s4/lgil3p.mpg
+lip/GRID/s4/lrak3n.mpg
+lip/GRID/s4/pbwjzs.mpg
+lip/GRID/s4/bwis6s.mpg
+lip/GRID/s4/srin4a.mpg
+lip/GRID/s4/pbwxza.mpg
+lip/GRID/s4/lbbq8a.mpg
+lip/GRID/s4/pwixza.mpg
+lip/GRID/s4/bbbf5p.mpg
+lip/GRID/s4/bgwo1p.mpg
+lip/GRID/s4/lwazza.mpg
+lip/GRID/s4/lriq4s.mpg
+lip/GRID/s4/pgwy7p.mpg
+lip/GRID/s4/bras3n.mpg
+lip/GRID/s4/lbbk4a.mpg
+lip/GRID/s4/lgiz2a.mpg
+lip/GRID/s4/prbj3p.mpg
+lip/GRID/s4/bbws8a.mpg
+lip/GRID/s4/brif2s.mpg
+lip/GRID/s4/lrarza.mpg
+lip/GRID/s4/bril7p.mpg
+lip/GRID/s4/lrbk9p.mpg
+lip/GRID/s4/swbi3p.mpg
+lip/GRID/s4/brwa2a.mpg
+lip/GRID/s4/bgwb2s.mpg
+lip/GRID/s4/pgbk5p.mpg
+lip/GRID/s4/srah4a.mpg
+lip/GRID/s4/pgaq4s.mpg
+lip/GRID/s4/lbwk7p.mpg
+lip/GRID/s4/lwwmza.mpg
+lip/GRID/s4/pwwq5n.mpg
+lip/GRID/s4/bgat5n.mpg
+lip/GRID/s4/pbiiza.mpg
+lip/GRID/s4/pbao8a.mpg
+lip/GRID/s4/pwwy2a.mpg
+lip/GRID/s4/srbu5p.mpg
+lip/GRID/s4/bwam8a.mpg
+lip/GRID/s4/lwie2s.mpg
+lip/GRID/s4/lgwm6a.mpg
+lip/GRID/s4/pgbq9p.mpg
+lip/GRID/s4/pwic5n.mpg
+lip/GRID/s4/lbbd8s.mpg
+lip/GRID/s4/lriq6a.mpg
+lip/GRID/s4/swbv2a.mpg
+lip/GRID/s4/sbwh4s.mpg
+lip/GRID/s4/pgwe3n.mpg
+lip/GRID/s4/bras5p.mpg
+lip/GRID/s4/bgim8s.mpg
+lip/GRID/s4/bwba4a.mpg
+lip/GRID/s4/pbwp5p.mpg
+lip/GRID/s4/lwws4a.mpg
+lip/GRID/s4/sbwu1n.mpg
+lip/GRID/s4/lgwg2a.mpg
+lip/GRID/s4/sgbc6a.mpg
+lip/GRID/s4/pwwq7p.mpg
+lip/GRID/s4/bbaf2a.mpg
+lip/GRID/s4/lgbf5n.mpg
+lip/GRID/s4/lbid2a.mpg
+lip/GRID/s4/srat9n.mpg
+lip/GRID/s4/lgil2s.mpg
+lip/GRID/s4/pwap9p.mpg
+lip/GRID/s4/brwt3p.mpg
+lip/GRID/s4/lwalzs.mpg
+lip/GRID/s4/pgij5n.mpg
+lip/GRID/s4/lbij5p.mpg
+lip/GRID/s4/lbwe3p.mpg
+lip/GRID/s4/pric2a.mpg
+lip/GRID/s4/srbozs.mpg
+lip/GRID/s4/lwar3n.mpg
+lip/GRID/s4/lwbr8s.mpg
+lip/GRID/s4/bbiy7n.mpg
+lip/GRID/s4/pwij2a.mpg
+lip/GRID/s4/bras4s.mpg
+lip/GRID/s4/sgbp1n.mpg
+lip/GRID/s4/bwba2s.mpg
+lip/GRID/s4/sbaa2s.mpg
+lip/GRID/s4/bbiy8s.mpg
+lip/GRID/s4/brir9n.mpg
+lip/GRID/s4/sraa7n.mpg
+lip/GRID/s4/lrix7n.mpg
+lip/GRID/s4/srah1n.mpg
+lip/GRID/s4/lgas1p.mpg
+lip/GRID/s4/pbio3p.mpg
+lip/GRID/s4/pbiu8a.mpg
+lip/GRID/s4/sbaa1n.mpg
+lip/GRID/s4/prwp9n.mpg
+lip/GRID/s4/pwap8s.mpg
+lip/GRID/s4/bginza.mpg
+lip/GRID/s4/bgbn7p.mpg
+lip/GRID/s4/lwar6a.mpg
+lip/GRID/s4/pbwp6a.mpg
+lip/GRID/s4/pbao5n.mpg
+lip/GRID/s4/bbar9p.mpg
+lip/GRID/s4/swbb7n.mpg
+lip/GRID/s4/bwbg6s.mpg
+lip/GRID/s4/pwbx7p.mpg
+lip/GRID/s4/lrak5p.mpg
+lip/GRID/s4/prwj5n.mpg
+lip/GRID/s4/sbwa9n.mpg
+lip/GRID/s4/swab3n.mpg
+lip/GRID/s4/bwwn5p.mpg
+lip/GRID/s4/prav8a.mpg
+lip/GRID/s4/srwo4s.mpg
+lip/GRID/s4/lgwtza.mpg
+lip/GRID/s4/lwik6s.mpg
+lip/GRID/s4/swwi5n.mpg
+lip/GRID/s4/bbws7p.mpg
+lip/GRID/s4/pgax8s.mpg
+lip/GRID/s4/bbbf4s.mpg
+lip/GRID/s4/bbie6s.mpg
+lip/GRID/s4/pwax4a.mpg
+lip/GRID/s4/srah3p.mpg
+lip/GRID/s4/sgwp6s.mpg
+lip/GRID/s4/bgim9p.mpg
+lip/GRID/s4/lwal1p.mpg
+lip/GRID/s4/lwak9n.mpg
+lip/GRID/s4/bbaz4a.mpg
+lip/GRID/s4/pgad6s.mpg
+lip/GRID/s4/pwbq2s.mpg
+lip/GRID/s4/brbs7n.mpg
+lip/GRID/s4/bbwm1n.mpg
+lip/GRID/s4/pgbe1p.mpg
+lip/GRID/s4/swwv5p.mpg
+lip/GRID/s4/sgbi9p.mpg
+lip/GRID/s4/bwbnzs.mpg
+lip/GRID/s4/lriq5p.mpg
+lip/GRID/s4/lbax7p.mpg
+lip/GRID/s4/pwic8a.mpg
+lip/GRID/s4/srau1p.mpg
+lip/GRID/s4/braf8a.mpg
+lip/GRID/s4/swbb9p.mpg
+lip/GRID/s4/swbi1n.mpg
+lip/GRID/s4/lgws7n.mpg
+lip/GRID/s4/lwws3p.mpg
+lip/GRID/s4/lgwm4s.mpg
+lip/GRID/s4/srwu8s.mpg
+lip/GRID/s4/prwd4a.mpg
+lip/GRID/s4/srbu3n.mpg
+lip/GRID/s4/lgws9p.mpg
+lip/GRID/s4/bbir3n.mpg
+lip/GRID/s4/lbaq1n.mpg
+lip/GRID/s4/sgio6a.mpg
+lip/GRID/s4/brwm8s.mpg
+lip/GRID/s4/pgwe6a.mpg
+lip/GRID/s4/pwad2a.mpg
+lip/GRID/s4/braz9p.mpg
+lip/GRID/s4/pwbj8s.mpg
+lip/GRID/s4/pbbp1p.mpg
+lip/GRID/s4/sbat4s.mpg
+lip/GRID/s4/prap4a.mpg
+lip/GRID/s4/sbaa3p.mpg
+lip/GRID/s4/pwbd4s.mpg
+lip/GRID/s4/lrwl2s.mpg
+lip/GRID/s4/pgiq2a.mpg
+lip/GRID/s4/pbab7n.mpg
+lip/GRID/s4/swwpzs.mpg
+lip/GRID/s4/lgbs6a.mpg
+lip/GRID/s4/pgak2a.mpg
+lip/GRID/s4/pgwr1n.mpg
+lip/GRID/s4/pgiq1p.mpg
+lip/GRID/s4/pwadzs.mpg
+lip/GRID/s4/bbwf8s.mpg
+lip/GRID/s8/bwis4a.mpg
+lip/GRID/s8/lbax1n.mpg
+lip/GRID/s8/srbn5n.mpg
+lip/GRID/s8/prwv9n.mpg
+lip/GRID/s8/srag7n.mpg
+lip/GRID/s8/lgaz2a.mpg
+lip/GRID/s8/pbbo7p.mpg
+lip/GRID/s8/bgaazs.mpg
+lip/GRID/s8/lrix3n.mpg
+lip/GRID/s8/lwbr3n.mpg
+lip/GRID/s8/sbag2s.mpg
+lip/GRID/s8/prac2a.mpg
+lip/GRID/s8/bbar4s.mpg
+lip/GRID/s8/bbws4a.mpg
+lip/GRID/s8/pgbkzs.mpg
+lip/GRID/s8/bgwh2s.mpg
+lip/GRID/s8/pwbj3n.mpg
+lip/GRID/s8/lgwf8a.mpg
+lip/GRID/s8/lrbk4s.mpg
+lip/GRID/s8/sgib1n.mpg
+lip/GRID/s8/swbu6s.mpg
+lip/GRID/s8/lrbq7n.mpg
+lip/GRID/s8/lbwy1p.mpg
+lip/GRID/s8/brir8a.mpg
+lip/GRID/s8/bbwf4s.mpg
+lip/GRID/s8/prbp2s.mpg
+lip/GRID/s8/swab2a.mpg
+lip/GRID/s8/lrix6a.mpg
+lip/GRID/s8/bbbz3p.mpg
+lip/GRID/s8/brie9p.mpg
+lip/GRID/s8/lbwk2s.mpg
+lip/GRID/s8/bwwg7p.mpg
+lip/GRID/s8/lbwk3p.mpg
+lip/GRID/s8/srwb4a.mpg
+lip/GRID/s8/brbs3n.mpg
+lip/GRID/s8/sgbv1n.mpg
+lip/GRID/s8/swbh7n.mpg
+lip/GRID/s8/sgiu5p.mpg
+lip/GRID/s8/bgwh4a.mpg
+lip/GRID/s8/pwiv4s.mpg
+lip/GRID/s8/lgwf6s.mpg
+lip/GRID/s8/prbv5n.mpg
+lip/GRID/s8/lgie3n.mpg
+lip/GRID/s8/lrwy6s.mpg
+lip/GRID/s8/bbazza.mpg
+lip/GRID/s8/sgwjza.mpg
+lip/GRID/s8/srbh2s.mpg
+lip/GRID/s8/sbba4a.mpg
+lip/GRID/s8/sbbt6a.mpg
+lip/GRID/s8/bwbt1p.mpg
+lip/GRID/s8/swin3n.mpg
+lip/GRID/s8/srwo1p.mpg
+lip/GRID/s8/lbixza.mpg
+lip/GRID/s8/sbif8s.mpg
+lip/GRID/s8/swbo1n.mpg
+lip/GRID/s8/brir7p.mpg
+lip/GRID/s8/pbbo8a.mpg
+lip/GRID/s8/swan9p.mpg
+lip/GRID/s8/lrbrza.mpg
+lip/GRID/s8/bgwu2a.mpg
+lip/GRID/s8/lgbz5p.mpg
+lip/GRID/s8/pbbv2a.mpg
+lip/GRID/s8/brifza.mpg
+lip/GRID/s8/lbbx8a.mpg
+lip/GRID/s8/pbiu3p.mpg
+lip/GRID/s8/sbis6s.mpg
+lip/GRID/s8/lbbq1n.mpg
+lip/GRID/s8/lrwk7n.mpg
+lip/GRID/s8/bwbg3p.mpg
+lip/GRID/s8/sbbnzs.mpg
+lip/GRID/s8/swia5n.mpg
+lip/GRID/s8/pbwo9n.mpg
+lip/GRID/s8/sgiu6a.mpg
+lip/GRID/s8/swwv1p.mpg
+lip/GRID/s8/bwwn1p.mpg
+lip/GRID/s8/brwg1p.mpg
+lip/GRID/s8/lrwk8s.mpg
+lip/GRID/s8/srbn6s.mpg
+lip/GRID/s8/bgig1p.mpg
+lip/GRID/s8/lwbe7p.mpg
+lip/GRID/s8/pbbi1n.mpg
+lip/GRID/s8/lgws3n.mpg
+lip/GRID/s8/brwm6a.mpg
+lip/GRID/s8/sgau9p.mpg
+lip/GRID/s8/lgir1n.mpg
+lip/GRID/s8/sbbm9n.mpg
+lip/GRID/s8/pbin7n.mpg
+lip/GRID/s8/srbt9n.mpg
+lip/GRID/s8/sraa3n.mpg
+lip/GRID/s8/bgwh1n.mpg
+lip/GRID/s8/bbbl3n.mpg
+lip/GRID/s8/pwap5p.mpg
+lip/GRID/s8/lbiv8s.mpg
+lip/GRID/s8/sgwi8s.mpg
+lip/GRID/s8/bwwt4s.mpg
+lip/GRID/s8/sgib2s.mpg
+lip/GRID/s8/bbiy3n.mpg
+lip/GRID/s8/lbap8s.mpg
+lip/GRID/s8/pgbq5p.mpg
+lip/GRID/s8/sbwh1p.mpg
+lip/GRID/s8/bbbz1n.mpg
+lip/GRID/s8/lwik1n.mpg
+lip/GRID/s8/bwwt3n.mpg
+lip/GRID/s8/pgic8s.mpg
+lip/GRID/s8/lbweza.mpg
+lip/GRID/s8/bbiy4s.mpg
+lip/GRID/s8/swwo5n.mpg
+lip/GRID/s8/lrid2s.mpg
+lip/GRID/s8/brbz8s.mpg
+lip/GRID/s8/lgws4s.mpg
+lip/GRID/s8/pwwx5n.mpg
+lip/GRID/s8/swan8s.mpg
+lip/GRID/s8/sgab5n.mpg
+lip/GRID/s8/sgiozs.mpg
+lip/GRID/s8/pwii8a.mpg
+lip/GRID/s8/prbp4a.mpg
+lip/GRID/s8/swbiza.mpg
+lip/GRID/s8/pgax5p.mpg
+lip/GRID/s8/sgbi5p.mpg
+lip/GRID/s8/sbim3p.mpg
+lip/GRID/s8/bbak9n.mpg
+lip/GRID/s8/bwwa4a.mpg
+lip/GRID/s8/pwbc9n.mpg
+lip/GRID/s8/sraa6a.mpg
+lip/GRID/s8/sgwv6s.mpg
+lip/GRID/s8/bwbaza.mpg
+lip/GRID/s8/lbwk1n.mpg
+lip/GRID/s8/lwiq5n.mpg
+lip/GRID/s8/pgic7n.mpg
+lip/GRID/s8/brbl9n.mpg
+lip/GRID/s8/sgbc1p.mpg
+lip/GRID/s8/srim7n.mpg
+lip/GRID/s8/lbbq4a.mpg
+lip/GRID/s8/sbim1n.mpg
+lip/GRID/s8/sgbc2a.mpg
+lip/GRID/s8/pgax4s.mpg
+lip/GRID/s8/pgbd8a.mpg
+lip/GRID/s8/lraq5p.mpg
+lip/GRID/s8/bbbr7n.mpg
+lip/GRID/s8/bbalzs.mpg
+lip/GRID/s8/bbwz5n.mpg
+lip/GRID/s8/lbax4a.mpg
+lip/GRID/s8/bbae6s.mpg
+lip/GRID/s8/sgao5p.mpg
+lip/GRID/s8/lgae9p.mpg
+lip/GRID/s8/bwam3p.mpg
+lip/GRID/s8/swit7n.mpg
+lip/GRID/s8/lbbd5p.mpg
+lip/GRID/s8/pgax3n.mpg
+lip/GRID/s8/sbat1p.mpg
+lip/GRID/s8/lwwf2a.mpg
+lip/GRID/s8/bbir2a.mpg
+lip/GRID/s8/swah4s.mpg
+lip/GRID/s8/bbiy5p.mpg
+lip/GRID/s8/bgat1n.mpg
+lip/GRID/s8/sriazs.mpg
+lip/GRID/s8/bwbm6s.mpg
+lip/GRID/s8/bwbm5n.mpg
+lip/GRID/s8/sbam5n.mpg
+lip/GRID/s8/lwar2a.mpg
+lip/GRID/s8/bbwmza.mpg
+lip/GRID/s8/sgai2a.mpg
+lip/GRID/s8/pbwp1p.mpg
+lip/GRID/s8/lwwe9n.mpg
+lip/GRID/s8/sbam6s.mpg
+lip/GRID/s8/bbbsza.mpg
+lip/GRID/s8/sgwv8a.mpg
+lip/GRID/s8/prbi8s.mpg
+lip/GRID/s8/lbaj4s.mpg
+lip/GRID/s8/lwwl5p.mpg
+lip/GRID/s8/swbu7p.mpg
+lip/GRID/s8/sgiu3n.mpg
+lip/GRID/s8/bbwl9p.mpg
+lip/GRID/s8/lgws6a.mpg
+lip/GRID/s8/prio6a.mpg
+lip/GRID/s8/pgaq2a.mpg
+lip/GRID/s8/bbws2s.mpg
+lip/GRID/s8/sgib4a.mpg
+lip/GRID/s8/bwwnzs.mpg
+lip/GRID/s8/pgic9p.mpg
+lip/GRID/s8/sgbczs.mpg
+lip/GRID/s8/sbbg7p.mpg
+lip/GRID/s8/swah5p.mpg
+lip/GRID/s8/bgim6a.mpg
+lip/GRID/s8/lbwd9p.mpg
+lip/GRID/s8/swbb6a.mpg
+lip/GRID/s8/priu8s.mpg
+lip/GRID/s8/pbwc2s.mpg
+lip/GRID/s8/lrwy8a.mpg
+lip/GRID/s8/bgag5p.mpg
+lip/GRID/s8/bwimza.mpg
+lip/GRID/s8/sran3p.mpg
+lip/GRID/s8/pwbp9p.mpg
+lip/GRID/s8/bbay7n.mpg
+lip/GRID/s8/lbijzs.mpg
+lip/GRID/s8/swab1p.mpg
+lip/GRID/s8/lwwr9p.mpg
+lip/GRID/s8/pwwj7n.mpg
+lip/GRID/s8/srat5n.mpg
+lip/GRID/s8/lriq2a.mpg
+lip/GRID/s8/pbau8a.mpg
+lip/GRID/s8/lwwfzs.mpg
+lip/GRID/s8/prib8a.mpg
+lip/GRID/s8/brir6s.mpg
+lip/GRID/s8/prav3p.mpg
+lip/GRID/s8/prab9n.mpg
+lip/GRID/s8/pwii7p.mpg
+lip/GRID/s8/pgwe2a.mpg
+lip/GRID/s8/lbbq3p.mpg
+lip/GRID/s8/pgip5n.mpg
+lip/GRID/s8/swbb5p.mpg
+lip/GRID/s8/pwwd4s.mpg
+lip/GRID/s8/pwbp7n.mpg
+lip/GRID/s8/bbiy6a.mpg
+lip/GRID/s8/srba9p.mpg
+lip/GRID/s8/bgba4s.mpg
+lip/GRID/s8/bgba5p.mpg
+lip/GRID/s8/bwiz6s.mpg
+lip/GRID/s8/sbif9p.mpg
+lip/GRID/s8/bwbtzs.mpg
+lip/GRID/s8/srig4s.mpg
+lip/GRID/s8/bgitza.mpg
+lip/GRID/s8/sgio2a.mpg
+lip/GRID/s8/bgbg8s.mpg
+lip/GRID/s8/pbao4a.mpg
+lip/GRID/s8/sbbg8a.mpg
+lip/GRID/s8/bgis7n.mpg
+lip/GRID/s8/pwwq3p.mpg
+lip/GRID/s8/sbba2s.mpg
+lip/GRID/s8/bbbr8s.mpg
+lip/GRID/s8/lgbs2a.mpg
+lip/GRID/s8/pgad2s.mpg
+lip/GRID/s8/lwik3p.mpg
+lip/GRID/s8/bgba6a.mpg
+lip/GRID/s8/bbwz8a.mpg
+lip/GRID/s8/lrix4s.mpg
+lip/GRID/s8/bbwl7n.mpg
+lip/GRID/s8/briy9n.mpg
+lip/GRID/s8/srat6s.mpg
+lip/GRID/s8/swbu5n.mpg
+lip/GRID/s8/swau2s.mpg
+lip/GRID/s8/pgix1p.mpg
+lip/GRID/s8/lrak1p.mpg
+lip/GRID/s8/lwbe5n.mpg
+lip/GRID/s8/prapza.mpg
+lip/GRID/s8/bwwt6a.mpg
+lip/GRID/s8/bgbt8a.mpg
+lip/GRID/s8/bral6s.mpg
+lip/GRID/s8/sgbi6a.mpg
+lip/GRID/s8/srat7p.mpg
+lip/GRID/s8/brwm4s.mpg
+lip/GRID/s8/pwwj9p.mpg
+lip/GRID/s8/lgal3p.mpg
+lip/GRID/s8/sgwc5p.mpg
+lip/GRID/s8/prbi7n.mpg
+lip/GRID/s3/brbs8n.mpg
+lip/GRID/s3/pgbk4n.mpg
+lip/GRID/s3/prav6n.mpg
+lip/GRID/s3/sgbc6p.mpg
+lip/GRID/s3/lgbs5s.mpg
+lip/GRID/s3/swwv5s.mpg
+lip/GRID/s3/lrwe9s.mpg
+lip/GRID/s3/bbbf7a.mpg
+lip/GRID/s3/lgiz1s.mpg
+lip/GRID/s3/pwap9s.mpg
+lip/GRID/s3/bgat8p.mpg
+lip/GRID/s3/bbwgzp.mpg
+lip/GRID/s3/pwwk5a.mpg
+lip/GRID/s3/pbih9s.mpg
+lip/GRID/s3/lgbm3a.mpg
+lip/GRID/s3/bgin1a.mpg
+lip/GRID/s3/brwg5s.mpg
+lip/GRID/s3/pwaqzp.mpg
+lip/GRID/s3/lgil3s.mpg
+lip/GRID/s3/srit6n.mpg
+lip/GRID/s3/sria5s.mpg
+lip/GRID/s3/pbwjzn.mpg
+lip/GRID/s3/lwws5a.mpg
+lip/GRID/s3/pwic9a.mpg
+lip/GRID/s3/lbwy5s.mpg
+lip/GRID/s3/lwir1s.mpg
+lip/GRID/s3/lwal3a.mpg
+lip/GRID/s3/bgaa6p.mpg
+lip/GRID/s3/sbit2p.mpg
+lip/GRID/s3/lrbe5s.mpg
+lip/GRID/s3/lwae7s.mpg
+lip/GRID/s3/srin5a.mpg
+lip/GRID/s3/bgwb2n.mpg
+lip/GRID/s3/swab7a.mpg
+lip/GRID/s3/bbizzp.mpg
+lip/GRID/s3/bgig5s.mpg
+lip/GRID/s3/pbbc4p.mpg
+lip/GRID/s3/srihzp.mpg
+lip/GRID/s3/lgir8p.mpg
+lip/GRID/s3/pwbd5s.mpg
+lip/GRID/s3/lraq8n.mpg
+lip/GRID/s3/swau8p.mpg
+lip/GRID/s3/bwif8n.mpg
+lip/GRID/s3/bwat2p.mpg
+lip/GRID/s3/lbix2n.mpg
+lip/GRID/s3/bbwm5a.mpg
+lip/GRID/s3/brbg1s.mpg
+lip/GRID/s3/pbwxzp.mpg
+lip/GRID/s3/lbwk8p.mpg
+lip/GRID/s3/pbaczp.mpg
+lip/GRID/s3/lbad4n.mpg
+lip/GRID/s3/bgia2p.mpg
+lip/GRID/s3/sbim7s.mpg
+lip/GRID/s3/bwwa6n.mpg
+lip/GRID/s3/swab5s.mpg
+lip/GRID/s3/pwaj4n.mpg
+lip/GRID/s3/lbij6p.mpg
+lip/GRID/s3/bwbn1s.mpg
+lip/GRID/s3/lrblzp.mpg
+lip/GRID/s3/lray5a.mpg
+lip/GRID/s3/lwiy7a.mpg
+lip/GRID/s3/pbio4p.mpg
+lip/GRID/s3/bwwt9s.mpg
+lip/GRID/s3/bwat1s.mpg
+lip/GRID/s3/pgaq4n.mpg
+lip/GRID/s3/lrwr7s.mpg
+lip/GRID/s3/bbaf1s.mpg
+lip/GRID/s3/pgaq7a.mpg
+lip/GRID/s3/braf7s.mpg
+lip/GRID/s3/lwiy5s.mpg
+lip/GRID/s3/swah9s.mpg
+lip/GRID/s3/bwag4p.mpg
+lip/GRID/s3/lwiy4n.mpg
+lip/GRID/s3/swwi9a.mpg
+lip/GRID/s3/brif5a.mpg
+lip/GRID/s3/lrwl3s.mpg
+lip/GRID/s3/lwirzn.mpg
+lip/GRID/s3/swwp2p.mpg
+lip/GRID/s3/bwwn5s.mpg
+lip/GRID/s3/srig8n.mpg
+lip/GRID/s3/prwj8p.mpg
+lip/GRID/s3/lrwzzn.mpg
+lip/GRID/s3/sgap1a.mpg
+lip/GRID/s3/sbbn7a.mpg
+lip/GRID/s3/lrbr2n.mpg
+lip/GRID/s3/pwwy3a.mpg
+lip/GRID/s3/bbal7a.mpg
+lip/GRID/s3/bwif9s.mpg
+lip/GRID/s3/pgiq1s.mpg
+lip/GRID/s3/bwam8p.mpg
+lip/GRID/s3/lrwfzp.mpg
+lip/GRID/s3/bgbu1s.mpg
+lip/GRID/s3/bwam7s.mpg
+lip/GRID/s3/pbwc8p.mpg
+lip/GRID/s3/pgbq8n.mpg
+lip/GRID/s3/bgwu5s.mpg
+lip/GRID/s3/bwbn3a.mpg
+lip/GRID/s3/pgak2p.mpg
+lip/GRID/s3/lrwz2p.mpg
+lip/GRID/s3/pwwd9s.mpg
+lip/GRID/s3/pgax9s.mpg
+lip/GRID/s3/pwbx9a.mpg
+lip/GRID/s3/prbd1a.mpg
+lip/GRID/s3/pwwq8p.mpg
+lip/GRID/s3/lgir7s.mpg
+lip/GRID/s3/pgwr5a.mpg
+lip/GRID/s3/swaizp.mpg
+lip/GRID/s3/bbir4n.mpg
+lip/GRID/s3/swwi7s.mpg
+lip/GRID/s3/sgao8n.mpg
+lip/GRID/s3/lrid7s.mpg
+lip/GRID/s3/sbwu3s.mpg
+lip/GRID/s3/pbwp7a.mpg
+lip/GRID/s3/sgiv1a.mpg
+lip/GRID/s3/bwaa1a.mpg
+lip/GRID/s3/pbiizp.mpg
+lip/GRID/s3/bwwn7a.mpg
+lip/GRID/s3/brwazn.mpg
+lip/GRID/s3/lbby3a.mpg
+lip/GRID/s3/srah2n.mpg
+lip/GRID/s3/sbag6n.mpg
+lip/GRID/s3/sbbu1a.mpg
+lip/GRID/s3/bbil1s.mpg
+lip/GRID/s3/bgag8n.mpg
+lip/GRID/s3/bgwu4n.mpg
+lip/GRID/s3/pbio3s.mpg
+lip/GRID/s3/bbal5s.mpg
+lip/GRID/s3/sraa8n.mpg
+lip/GRID/s3/lwae9a.mpg
+lip/GRID/s3/sbbh3a.mpg
+lip/GRID/s3/srab1a.mpg
+lip/GRID/s3/bwis7s.mpg
+lip/GRID/s3/lraezn.mpg
+lip/GRID/s3/lbbk4p.mpg
+lip/GRID/s3/brwg4n.mpg
+lip/GRID/s3/pwbkzp.mpg
+lip/GRID/s3/bgaa4n.mpg
+lip/GRID/s3/brbm5s.mpg
+lip/GRID/s3/lwwm1a.mpg
+lip/GRID/s3/bgwu6p.mpg
+lip/GRID/s3/pgbq9s.mpg
+lip/GRID/s3/sbaa3s.mpg
+lip/GRID/s3/bwwh3a.mpg
+lip/GRID/s3/pwwd8n.mpg
+lip/GRID/s3/lbak1a.mpg
+lip/GRID/s3/lrid9a.mpg
+lip/GRID/s3/prav8p.mpg
+lip/GRID/s3/lbbe1a.mpg
+lip/GRID/s3/swwpzn.mpg
+lip/GRID/s3/bgbn8p.mpg
+lip/GRID/s3/sgbp2n.mpg
+lip/GRID/s3/bbas1a.mpg
+lip/GRID/s3/lgws9s.mpg
+lip/GRID/s3/sgbp3s.mpg
+lip/GRID/s3/lbip8n.mpg
+lip/GRID/s3/bgag9s.mpg
+lip/GRID/s3/sban2p.mpg
+lip/GRID/s3/prap4p.mpg
+lip/GRID/s3/bwam9a.mpg
+lip/GRID/s3/sbba6n.mpg
+lip/GRID/s3/bwis8p.mpg
+lip/GRID/s3/sgwx3a.mpg
+lip/GRID/s3/bbil3a.mpg
+lip/GRID/s3/sgwd1a.mpg
+lip/GRID/s3/bgwo1s.mpg
+lip/GRID/s3/bwwh1s.mpg
+lip/GRID/s3/lgwg3a.mpg
+lip/GRID/s3/lbwy4n.mpg
+lip/GRID/s3/swib3a.mpg
+lip/GRID/s3/bras6p.mpg
+lip/GRID/s3/sgwp9a.mpg
+lip/GRID/s3/swih5s.mpg
+lip/GRID/s3/srbb3s.mpg
+lip/GRID/s3/lwbl7a.mpg
+lip/GRID/s3/pgby4p.mpg
+lip/GRID/s3/sgwp7s.mpg
+lip/GRID/s3/bwwu1a.mpg
+lip/GRID/s3/brif2n.mpg
+lip/GRID/s3/swwp1s.mpg
+lip/GRID/s3/pbbi9a.mpg
+lip/GRID/s3/swab4n.mpg
+lip/GRID/s3/prio8n.mpg
+lip/GRID/s3/bgbuzn.mpg
+lip/GRID/s3/prbx3a.mpg
+lip/GRID/s3/lwik7s.mpg
+lip/GRID/s3/sbwh6p.mpg
+lip/GRID/s3/bgwb4p.mpg
+lip/GRID/s3/sria6p.mpg
+lip/GRID/s3/pgaq5s.mpg
+lip/GRID/s3/srbo1s.mpg
+lip/GRID/s3/pwbx7s.mpg
+lip/GRID/s3/pwij2p.mpg
+lip/GRID/s3/lbix5a.mpg
+lip/GRID/s3/sgwxzn.mpg
+lip/GRID/s3/bwwhzn.mpg
+lip/GRID/s3/pbbp1s.mpg
+lip/GRID/s3/lgaz4n.mpg
+lip/GRID/s3/swio1a.mpg
+lip/GRID/s3/srwb8p.mpg
+lip/GRID/s3/lbwy7a.mpg
+lip/GRID/s3/pwbk1a.mpg
+lip/GRID/s3/bgwb5a.mpg
+lip/GRID/s3/lwik8p.mpg
+lip/GRID/s3/pbav2p.mpg
+lip/GRID/s3/srbu4n.mpg
+lip/GRID/s3/lwbs1a.mpg
+lip/GRID/s3/bwwh2p.mpg
+lip/GRID/s3/lrikzn.mpg
+lip/GRID/s3/lbaq5a.mpg
+lip/GRID/s3/lbwk7s.mpg
+lip/GRID/s3/srwu9s.mpg
+lip/GRID/s3/bgan3s.mpg
+lip/GRID/s3/swbv1s.mpg
+lip/GRID/s3/lrbr5a.mpg
+lip/GRID/s3/bwwt8n.mpg
+lip/GRID/s3/bwbg6n.mpg
+lip/GRID/s3/sgii3a.mpg
+lip/GRID/s3/srwo4n.mpg
+lip/GRID/s3/swbo7s.mpg
+lip/GRID/s3/lrak7a.mpg
+lip/GRID/s3/bwwuzp.mpg
+lip/GRID/s3/brbm6p.mpg
+lip/GRID/s3/prwx4n.mpg
+lip/GRID/s3/bbafzn.mpg
+lip/GRID/s3/bwwn4n.mpg
+lip/GRID/s3/sbitzn.mpg
+lip/GRID/s3/bwbg7s.mpg
+lip/GRID/s3/srwi1s.mpg
+lip/GRID/s3/lbiq1a.mpg
+lip/GRID/s3/bbwf8n.mpg
+lip/GRID/s3/bgbh3s.mpg
+lip/GRID/s3/sbim9a.mpg
+lip/GRID/s3/pbai3s.mpg
+lip/GRID/s3/bris1s.mpg
+lip/GRID/s3/pgwlzp.mpg
+lip/GRID/s3/lbbq8p.mpg
+lip/GRID/s3/pbbc5a.mpg
+lip/GRID/s3/brwg7a.mpg
+lip/GRID/s3/bbir7a.mpg
+lip/GRID/s3/lwie2n.mpg
+lip/GRID/s3/sgbi9s.mpg
+lip/GRID/s3/sbim6n.mpg
+lip/GRID/s3/bgbn6n.mpg
+lip/GRID/s3/swbo8p.mpg
+lip/GRID/s3/sbwn9s.mpg
+lip/GRID/s3/lrik1s.mpg
+lip/GRID/s3/pgad6n.mpg
+lip/GRID/s3/lray3s.mpg
+lip/GRID/s3/lbby1s.mpg
+lip/GRID/s3/lgiz3a.mpg
+lip/GRID/s3/swab6p.mpg
+lip/GRID/s3/lgas1s.mpg
+lip/GRID/s3/lwbz5a.mpg
+lip/GRID/s3/sgiu9s.mpg
+lip/GRID/s3/pwiv8n.mpg
+lip/GRID/s1/bgan6p.mpg
+lip/GRID/s1/sbin1a.mpg
+lip/GRID/s1/bgbb1s.mpg
+lip/GRID/s1/lbay1a.mpg
+lip/GRID/s1/brbg4p.mpg
+lip/GRID/s1/lgwm9a.mpg
+lip/GRID/s1/prap5s.mpg
+lip/GRID/s1/brag1a.mpg
+lip/GRID/s1/pwwezn.mpg
+lip/GRID/s1/sgbc9a.mpg
+lip/GRID/s1/bgaa6n.mpg
+lip/GRID/s1/lwiy7s.mpg
+lip/GRID/s1/srbizp.mpg
+lip/GRID/s1/brbazp.mpg
+lip/GRID/s1/prap4n.mpg
+lip/GRID/s1/pgwzzp.mpg
+lip/GRID/s1/bragzp.mpg
+lip/GRID/s1/swab7s.mpg
+lip/GRID/s1/sbaa7a.mpg
+lip/GRID/s1/bbwg3a.mpg
+lip/GRID/s1/swbo9s.mpg
+lip/GRID/s1/bgbh5s.mpg
+lip/GRID/s1/sbim9s.mpg
+lip/GRID/s1/pbwdzp.mpg
+lip/GRID/s1/swwi8n.mpg
+lip/GRID/s1/sriuzp.mpg
+lip/GRID/s1/sbwh7s.mpg
+lip/GRID/s1/pbbv6n.mpg
+lip/GRID/s1/sbim8n.mpg
+lip/GRID/s1/pgbr3a.mpg
+lip/GRID/s1/bbwm5s.mpg
+lip/GRID/s1/sgbx1a.mpg
+lip/GRID/s1/prbd2p.mpg
+lip/GRID/s1/prwq4p.mpg
+lip/GRID/s1/srabzn.mpg
+lip/GRID/s1/lrbe9a.mpg
+lip/GRID/s1/prii7s.mpg
+lip/GRID/s1/sria9a.mpg
+lip/GRID/s1/prwd5s.mpg
+lip/GRID/s1/brwg9a.mpg
+lip/GRID/s1/pbbc5s.mpg
+lip/GRID/s1/lwir5a.mpg
+lip/GRID/s1/srbb5s.mpg
+lip/GRID/s1/lbwlzp.mpg
+lip/GRID/s1/lwik8n.mpg
+lip/GRID/s1/bwis9s.mpg
+lip/GRID/s1/lwws6p.mpg
+lip/GRID/s1/pwij5a.mpg
+lip/GRID/s1/pgad8n.mpg
+lip/GRID/s1/bbas2p.mpg
+lip/GRID/s1/bbiz2p.mpg
+lip/GRID/s1/sbbh3s.mpg
+lip/GRID/s1/pbwp7s.mpg
+lip/GRID/s1/prac9a.mpg
+lip/GRID/s1/prwq2n.mpg
+lip/GRID/s1/bbws9s.mpg
+lip/GRID/s1/bbbs6p.mpg
+lip/GRID/s1/pbivzp.mpg
+lip/GRID/s1/srbb6p.mpg
+lip/GRID/s1/lwaz2p.mpg
+lip/GRID/s1/lgwg5a.mpg
+lip/GRID/s1/sgbp6p.mpg
+lip/GRID/s1/pgbe2n.mpg
+lip/GRID/s1/prwx6n.mpg
+lip/GRID/s1/bbie8n.mpg
+lip/GRID/s1/lgas5a.mpg
+lip/GRID/s1/lgil4n.mpg
+lip/GRID/s1/lrak9a.mpg
+lip/GRID/s1/prii6n.mpg
+lip/GRID/s1/pwwr1a.mpg
+lip/GRID/s1/bbwt1a.mpg
+lip/GRID/s1/sbwb3s.mpg
+lip/GRID/s1/brwg6n.mpg
+lip/GRID/s1/prap7a.mpg
+lip/GRID/s1/bgbn9s.mpg
+lip/GRID/s1/lwafzp.mpg
+lip/GRID/s1/sbwo2p.mpg
+lip/GRID/s1/lwaz3a.mpg
+lip/GRID/s1/pbbi8n.mpg
+lip/GRID/s1/bgwi1a.mpg
+lip/GRID/s1/pbwxzn.mpg
+lip/GRID/s1/lgaf6p.mpg
+lip/GRID/s1/bgit5s.mpg
+lip/GRID/s1/lrik5a.mpg
+lip/GRID/s1/sria8p.mpg
+lip/GRID/s1/bgia2n.mpg
+lip/GRID/s1/bgan4n.mpg
+lip/GRID/s1/lbiq2p.mpg
+lip/GRID/s1/lray4n.mpg
+lip/GRID/s1/sbwb5a.mpg
+lip/GRID/s1/lbbezn.mpg
+lip/GRID/s1/lwbz4n.mpg
+lip/GRID/s1/lgbm4p.mpg
+lip/GRID/s1/sbbu1s.mpg
+lip/GRID/s1/sgav7a.mpg
+lip/GRID/s1/bwwh4p.mpg
+lip/GRID/s1/bgbh7a.mpg
+lip/GRID/s1/lbbrzp.mpg
+lip/GRID/s1/pgix9a.mpg
+lip/GRID/s1/bwba6p.mpg
+lip/GRID/s1/bbaz4n.mpg
+lip/GRID/s1/srbb7a.mpg
+lip/GRID/s1/srwv2p.mpg
+lip/GRID/s1/bwba4n.mpg
+lip/GRID/s1/lgbg1a.mpg
+lip/GRID/s1/bwwu2p.mpg
+lip/GRID/s1/srwc1a.mpg
+lip/GRID/s1/lbwr4p.mpg
+lip/GRID/s1/prwx7s.mpg
+lip/GRID/s1/lbid4p.mpg
+lip/GRID/s1/pwwrzp.mpg
+lip/GRID/s1/sriu1a.mpg
+lip/GRID/s1/brbg3s.mpg
+lip/GRID/s1/pwaq3a.mpg
+lip/GRID/s1/lbak3a.mpg
+lip/GRID/s1/sbwu6p.mpg
+lip/GRID/s1/sbiazn.mpg
+lip/GRID/s1/brbm7s.mpg
+lip/GRID/s1/sbwh8p.mpg
+lip/GRID/s1/lwbz5s.mpg
+lip/GRID/s1/sgwd2p.mpg
+lip/GRID/s1/bwim5s.mpg
+lip/GRID/s1/sgbj1s.mpg
+lip/GRID/s1/swio3a.mpg
+lip/GRID/s1/bbaz6p.mpg
+lip/GRID/s1/pripzn.mpg
+lip/GRID/s1/lbaq4n.mpg
+lip/GRID/s1/pwaj9a.mpg
+lip/GRID/s1/lgal9s.mpg
+lip/GRID/s1/sbbb1a.mpg
+lip/GRID/s1/srwczp.mpg
+lip/GRID/s1/bwam8n.mpg
+lip/GRID/s1/brif6p.mpg
+lip/GRID/s1/bwaa1s.mpg
+lip/GRID/s1/swih8p.mpg
+lip/GRID/s1/pwbx8n.mpg
+lip/GRID/s1/bwis8n.mpg
+lip/GRID/s1/sran8n.mpg
+lip/GRID/s1/lgbs9a.mpg
+lip/GRID/s1/srao1a.mpg
+lip/GRID/s1/pwby1a.mpg
+lip/GRID/s1/praj2p.mpg
+lip/GRID/s1/bwim6p.mpg
+lip/GRID/s1/sgbv9s.mpg
+lip/GRID/s1/bwwu3a.mpg
+lip/GRID/s1/lrwl4n.mpg
+lip/GRID/s1/lgwm8p.mpg
+lip/GRID/s1/bbiz1s.mpg
+lip/GRID/s1/prwk1a.mpg
+lip/GRID/s1/lwae8n.mpg
+lip/GRID/s1/lrie1a.mpg
+lip/GRID/s1/pwbk3a.mpg
+lip/GRID/s1/srin5s.mpg
+lip/GRID/s1/bbaf2n.mpg
+lip/GRID/s1/sgio7s.mpg
+lip/GRID/s1/sgiv2p.mpg
+lip/GRID/s1/pwwq9s.mpg
+lip/GRID/s1/lrae3s.mpg
+lip/GRID/s1/sbig7a.mpg
+lip/GRID/s1/lwik9s.mpg
+lip/GRID/s1/lgas3s.mpg
+lip/GRID/s1/prwq3s.mpg
+lip/GRID/s1/lbax8n.mpg
+lip/GRID/s1/srwv3a.mpg
+lip/GRID/s1/lrws1a.mpg
+lip/GRID/s1/lrbl3a.mpg
+lip/GRID/s1/brbm9a.mpg
+lip/GRID/s1/lwwm2p.mpg
+lip/GRID/s1/sgap3a.mpg
+lip/GRID/s1/sgap2p.mpg
+lip/GRID/s1/sgib9s.mpg
+lip/GRID/s1/bwwh2n.mpg
+lip/GRID/s1/swaizn.mpg
+lip/GRID/s1/pbiizn.mpg
+lip/GRID/s1/sgwdzn.mpg
+lip/GRID/s1/lbbk7a.mpg
+lip/GRID/s1/bbwm6p.mpg
+lip/GRID/s1/pbap1a.mpg
+lip/GRID/s1/pbii2p.mpg
+lip/GRID/s1/priv7a.mpg
+lip/GRID/s1/bgahzn.mpg
+lip/GRID/s1/brbm6n.mpg
+lip/GRID/s1/swib5a.mpg
+lip/GRID/s1/swab6n.mpg
+lip/GRID/s1/pwix1s.mpg
+lip/GRID/s1/sbwu7a.mpg
+lip/GRID/s1/bwig3a.mpg
+lip/GRID/s1/swab9a.mpg
+lip/GRID/s1/prwj8n.mpg
+lip/GRID/s1/sgbc8p.mpg
+lip/GRID/s1/brbt1s.mpg
+lip/GRID/s1/sbwb4p.mpg
+lip/GRID/s1/lgif1s.mpg
+lip/GRID/s1/bram5a.mpg
+lip/GRID/s1/srwb8n.mpg
+lip/GRID/s1/lwwf7s.mpg
+lip/GRID/s1/lgamzp.mpg
+lip/GRID/s1/prbp9s.mpg
+lip/GRID/s1/srbh8n.mpg
+lip/GRID/s1/lbad8p.mpg
+lip/GRID/s1/bris4p.mpg
+lip/GRID/s1/srwi5a.mpg
+lip/GRID/s1/sban2n.mpg
+lip/GRID/s1/lgaf4n.mpg
+lip/GRID/s1/bras9a.mpg
+lip/GRID/s1/lgbgzp.mpg
+lip/GRID/s1/prwd4n.mpg
+lip/GRID/s1/swib4p.mpg
+lip/GRID/s1/lgil5s.mpg
+lip/GRID/s1/bwwh5a.mpg
+lip/GRID/s1/pbwp6n.mpg
+lip/GRID/s1/brim1a.mpg
+lip/GRID/s1/lbbr1a.mpg
+lip/GRID/s1/sbwh6n.mpg
+lip/GRID/s1/sbbu3a.mpg
+lip/GRID/s1/pbav4p.mpg
+lip/GRID/s1/lgaf5s.mpg
+lip/GRID/s1/lwwf6n.mpg
+lip/GRID/s1/lbby3s.mpg
+lip/GRID/s1/pgae1a.mpg
+lip/GRID/s1/pbbv7s.mpg
+lip/GRID/s1/pgbk6n.mpg
+lip/GRID/s1/sgio9a.mpg
+lip/GRID/s1/lgwg4p.mpg
+lip/GRID/s1/pbio5s.mpg
+lip/GRID/s1/lwwm3a.mpg
+lip/GRID/s1/bwag5s.mpg
+lip/GRID/s1/sbia3a.mpg
+lip/GRID/s1/bbil3s.mpg
+lip/GRID/s1/sria6n.mpg
+lip/GRID/s1/swwv7s.mpg
+lip/GRID/s1/bgbo1a.mpg
+lip/GRID/s1/pwax6p.mpg
+lip/GRID/s1/sbig6p.mpg
+lip/GRID/s1/sgwd1s.mpg
+lip/GRID/s1/sgbv8n.mpg
+lip/GRID/s1/sbwozn.mpg
+lip/GRID/s1/bwigzn.mpg
+lip/GRID/s1/lrak7s.mpg
+lip/GRID/s1/prwd7a.mpg
+lip/GRID/s1/lbwr5a.mpg
+lip/GRID/s1/lgir8n.mpg
+lip/GRID/s1/sbwu4n.mpg
+lip/GRID/s1/brwt6p.mpg
+lip/GRID/s1/lrbe7s.mpg
+lip/GRID/s1/lwbl6n.mpg
+lip/GRID/s1/lrak6n.mpg
+lip/GRID/s1/pwbk1s.mpg
+lip/GRID/s1/bgau1a.mpg
+lip/GRID/s1/bwwu1s.mpg
+lip/GRID/s1/bbaf3s.mpg
+lip/GRID/s1/srbo3s.mpg
+lip/GRID/s1/bwanzp.mpg
+lip/GRID/s1/pwixzn.mpg
+lip/GRID/s1/srau5a.mpg
+lip/GRID/s17/lrwj9s.mpg
+lip/GRID/s17/lgix9a.mpg
+lip/GRID/s17/briq7s.mpg
+lip/GRID/s17/lgwz1a.mpg
+lip/GRID/s17/swbt9a.mpg
+lip/GRID/s17/bgwtzn.mpg
+lip/GRID/s17/pgwj5s.mpg
+lip/GRID/s17/lbapzp.mpg
+lip/GRID/s17/pwbc3a.mpg
+lip/GRID/s17/prit8n.mpg
+lip/GRID/s17/pwbi7a.mpg
+lip/GRID/s17/pbbu2p.mpg
+lip/GRID/s17/bgwt2p.mpg
+lip/GRID/s17/pbwu7a.mpg
+lip/GRID/s17/lbwj4p.mpg
+lip/GRID/s17/sgwu9a.mpg
+lip/GRID/s17/bbak2p.mpg
+lip/GRID/s17/lwidzp.mpg
+lip/GRID/s17/sbbm3a.mpg
+lip/GRID/s17/swat4p.mpg
+lip/GRID/s17/lrwx9a.mpg
+lip/GRID/s17/bbby4p.mpg
+lip/GRID/s17/brbr4n.mpg
+lip/GRID/s17/swaazn.mpg
+lip/GRID/s17/lgik1a.mpg
+lip/GRID/s17/lrii6n.mpg
+lip/GRID/s17/prwo9a.mpg
+lip/GRID/s17/lgid5s.mpg
+lip/GRID/s17/swbn5a.mpg
+lip/GRID/s17/lrwx7s.mpg
+lip/GRID/s17/lwip6n.mpg
+lip/GRID/s17/lbib7s.mpg
+lip/GRID/s17/lbwc9s.mpg
+lip/GRID/s17/swwb1a.mpg
+lip/GRID/s17/pwio2p.mpg
+lip/GRID/s17/prih3a.mpg
+lip/GRID/s17/bbwe6p.mpg
+lip/GRID/s17/pbbn7s.mpg
+lip/GRID/s17/pbbh4p.mpg
+lip/GRID/s17/lbwxzn.mpg
+lip/GRID/s17/bbij6n.mpg
+lip/GRID/s17/lrbqzp.mpg
+lip/GRID/s17/pwwv8p.mpg
+lip/GRID/s17/lrbx2n.mpg
+lip/GRID/s17/lrbdzn.mpg
+lip/GRID/s17/pwao6p.mpg
+lip/GRID/s17/lwwk7a.mpg
+lip/GRID/s17/lgaq6n.mpg
+lip/GRID/s17/lwaqzn.mpg
+lip/GRID/s17/bwbs2p.mpg
+lip/GRID/s17/prau2n.mpg
+lip/GRID/s17/pbwb4p.mpg
+lip/GRID/s17/lgwr5s.mpg
+lip/GRID/s17/sbiz1s.mpg
+lip/GRID/s17/lgad9s.mpg
+lip/GRID/s17/lrbj7a.mpg
+lip/GRID/s17/pbwh7s.mpg
+lip/GRID/s17/sgia4p.mpg
+lip/GRID/s17/prbizp.mpg
+lip/GRID/s17/brbe8p.mpg
+lip/GRID/s17/swim6p.mpg
+lip/GRID/s17/sgbh5s.mpg
+lip/GRID/s17/pbbh5a.mpg
+lip/GRID/s17/lbwd1a.mpg
+lip/GRID/s17/brik2n.mpg
+lip/GRID/s17/pban3s.mpg
+lip/GRID/s17/sbwm5s.mpg
+lip/GRID/s17/brbe6n.mpg
+lip/GRID/s17/prab2p.mpg
+lip/GRID/s17/pwao7a.mpg
+lip/GRID/s17/prihzn.mpg
+lip/GRID/s17/lwix1s.mpg
+lip/GRID/s17/bwiy9a.mpg
+lip/GRID/s17/pbit2n.mpg
+lip/GRID/s17/pbaa6p.mpg
+lip/GRID/s17/pbat8p.mpg
+lip/GRID/s17/srwg6n.mpg
+lip/GRID/s17/pwwv6n.mpg
+lip/GRID/s17/pgav5s.mpg
+lip/GRID/s17/swba5s.mpg
+lip/GRID/s17/pbbh2n.mpg
+lip/GRID/s17/prwo6n.mpg
+lip/GRID/s17/srbt2p.mpg
+lip/GRID/s17/pgbv8n.mpg
+lip/GRID/s17/lwij4p.mpg
+lip/GRID/s17/lwwrzp.mpg
+lip/GRID/s17/lbio6p.mpg
+lip/GRID/s17/lrwj8n.mpg
+lip/GRID/s17/pgac4p.mpg
+lip/GRID/s17/swba4n.mpg
+lip/GRID/s17/lgaezp.mpg
+lip/GRID/s17/bgaz9a.mpg
+lip/GRID/s17/brae3s.mpg
+lip/GRID/s17/sgbh7a.mpg
+lip/GRID/s17/sgah3a.mpg
+lip/GRID/s17/pwab6n.mpg
+lip/GRID/s17/sgwi1a.mpg
+lip/GRID/s17/bwwm1s.mpg
+lip/GRID/s17/lwaq1s.mpg
+lip/GRID/s17/bgir9s.mpg
+lip/GRID/s17/sraf9s.mpg
+lip/GRID/s17/pwwc5s.mpg
+lip/GRID/s17/bray4n.mpg
+lip/GRID/s17/bwbf4p.mpg
+lip/GRID/s17/lbiu8n.mpg
+lip/GRID/s17/lriv4n.mpg
+lip/GRID/s17/swwa8n.mpg
+lip/GRID/s17/prwo8p.mpg
+lip/GRID/s17/lbivzp.mpg
+lip/GRID/s17/pwbi4n.mpg
+lip/GRID/s17/sgig8p.mpg
+lip/GRID/s17/lraj1s.mpg
+lip/GRID/s17/bwws7a.mpg
+lip/GRID/s17/brid8n.mpg
+lip/GRID/s17/sbwm6p.mpg
+lip/GRID/s17/pbia1s.mpg
+lip/GRID/s17/bwal5a.mpg
+lip/GRID/s17/pbit3s.mpg
+lip/GRID/s17/pgii2n.mpg
+lip/GRID/s17/pbwu6p.mpg
+lip/GRID/s17/sgbb2p.mpg
+lip/GRID/s17/pwbv5a.mpg
+lip/GRID/s17/pbbu1s.mpg
+lip/GRID/s17/pgii3s.mpg
+lip/GRID/s17/lbwj2n.mpg
+lip/GRID/s17/prwv3a.mpg
+lip/GRID/s17/sbwg1s.mpg
+lip/GRID/s17/lwbd6n.mpg
+lip/GRID/s17/pgav4n.mpg
+lip/GRID/s17/pwwc4n.mpg
+lip/GRID/s17/sgbb1s.mpg
+lip/GRID/s17/lbac2p.mpg
+lip/GRID/s17/sram3s.mpg
+lip/GRID/s17/pwwp5a.mpg
+lip/GRID/s17/sram2n.mpg
+lip/GRID/s17/pgwx3s.mpg
+lip/GRID/s17/lrap5s.mpg
+lip/GRID/s17/lbai6p.mpg
+lip/GRID/s17/lrav9s.mpg
+lip/GRID/s17/bbakzn.mpg
+lip/GRID/s17/lgiq5a.mpg
+lip/GRID/s17/srbazp.mpg
+lip/GRID/s17/lwid1a.mpg
+lip/GRID/s17/bbwl1a.mpg
+lip/GRID/s17/lwbk1s.mpg
+lip/GRID/s17/pwavzp.mpg
+lip/GRID/s17/lriv7a.mpg
+lip/GRID/s17/sbws8n.mpg
+lip/GRID/s17/lrip1s.mpg
+lip/GRID/s17/bbbk5s.mpg
+lip/GRID/s17/pgav6p.mpg
+lip/GRID/s17/pwab8p.mpg
+lip/GRID/s17/sris4p.mpg
+lip/GRID/s17/brws1a.mpg
+lip/GRID/s17/bwws5s.mpg
+lip/GRID/s17/lrbx3s.mpg
+lip/GRID/s17/pwao4n.mpg
+lip/GRID/s17/lbac1s.mpg
+lip/GRID/s17/prabzn.mpg
+lip/GRID/s17/sbbm1s.mpg
+lip/GRID/s17/swbg8n.mpg
+lip/GRID/s17/pgbx1a.mpg
+lip/GRID/s17/bgif2p.mpg
+lip/GRID/s17/brae4p.mpg
+lip/GRID/s17/bwar7s.mpg
+lip/GRID/s17/pgwj4n.mpg
+lip/GRID/s17/prah6p.mpg
+lip/GRID/s17/lwad4p.mpg
+lip/GRID/s17/pgii5a.mpg
+lip/GRID/s17/bwbs1s.mpg
+lip/GRID/s17/sgan6p.mpg
+lip/GRID/s17/lbav5a.mpg
+lip/GRID/s17/lgbr3a.mpg
+lip/GRID/s17/lbav2n.mpg
+lip/GRID/s17/bbax8n.mpg
+lip/GRID/s17/srimzp.mpg
+lip/GRID/s17/sbaz5s.mpg
+lip/GRID/s17/lrbp9s.mpg
+lip/GRID/s17/lrac6n.mpg
+lip/GRID/s17/lbao8n.mpg
+lip/GRID/s17/lbwj3s.mpg
+lip/GRID/s17/lbwc8n.mpg
+lip/GRID/s17/pbwb3s.mpg
+lip/GRID/s17/lwbd9a.mpg
+lip/GRID/s17/lbwj5a.mpg
+lip/GRID/s17/pbwozn.mpg
+lip/GRID/s17/lwwk4n.mpg
+lip/GRID/s17/lwax4n.mpg
+lip/GRID/s17/bwaz1s.mpg
+lip/GRID/s17/lbav4p.mpg
+lip/GRID/s17/pgwqzp.mpg
+lip/GRID/s17/lbiv1a.mpg
+lip/GRID/s17/lbbv6n.mpg
+lip/GRID/s17/lwbk3a.mpg
+lip/GRID/s17/bbax9s.mpg
+lip/GRID/s17/pgai9a.mpg
+lip/GRID/s17/lriv5s.mpg
+lip/GRID/s17/pgac3s.mpg
+lip/GRID/s17/sbaz4n.mpg
+lip/GRID/s17/briy3a.mpg
+lip/GRID/s17/lrajzn.mpg
+lip/GRID/s17/pgiv2p.mpg
+lip/GRID/s17/bgil6p.mpg
+lip/GRID/s17/brwfzn.mpg
+lip/GRID/s17/lric3s.mpg
+lip/GRID/s17/bwiy7s.mpg
+lip/GRID/s17/pbinzp.mpg
+lip/GRID/s17/lbwp9a.mpg
+lip/GRID/s17/bgbf9s.mpg
+lip/GRID/s17/swwh2n.mpg
+lip/GRID/s17/bray7a.mpg
+lip/GRID/s17/lwad5a.mpg
+lip/GRID/s17/sgbu3s.mpg
+lip/GRID/s17/lbbv9a.mpg
+lip/GRID/s17/bwae9s.mpg
+lip/GRID/s17/pwib5a.mpg
+lip/GRID/s17/swbt6n.mpg
+lip/GRID/s17/sbas2p.mpg
+lip/GRID/s17/lwwe2p.mpg
+lip/GRID/s17/lgwl3a.mpg
+lip/GRID/s17/srwa5a.mpg
+lip/GRID/s17/swwu1s.mpg
+lip/GRID/s17/lgix7s.mpg
+lip/GRID/s17/lgbr2p.mpg
+lip/GRID/s17/sbwg2p.mpg
+lip/GRID/s17/pgbc6n.mpg
+lip/GRID/s17/lgad8n.mpg
+lip/GRID/s17/lgby4n.mpg
+lip/GRID/s17/bgbs8p.mpg
+lip/GRID/s17/pgac2n.mpg
+lip/GRID/s17/bbbe2p.mpg
+lip/GRID/s17/sbal6n.mpg
+lip/GRID/s17/srag1a.mpg
+lip/GRID/s17/brwf2p.mpg
+lip/GRID/s17/lwax7a.mpg
+lip/GRID/s17/pbba8n.mpg
+lip/GRID/s17/swwn9a.mpg
+lip/GRID/s17/lwwy5a.mpg
+lip/GRID/s17/sgwo5a.mpg
+lip/GRID/s17/lgak4p.mpg
+lip/GRID/s17/pwiu7a.mpg
+lip/GRID/s17/brwl6p.mpg
+lip/GRID/s17/pwbp1a.mpg
+lip/GRID/s17/prau5a.mpg
+lip/GRID/s17/srbm6n.mpg
+lip/GRID/s17/sraf8n.mpg
+lip/GRID/s17/pwwp2n.mpg
+lip/GRID/s17/swag5s.mpg
+lip/GRID/s17/brarzn.mpg
+lip/GRID/s17/pwbo9s.mpg
+lip/GRID/s17/bbwlzp.mpg
+lip/GRID/s17/briezp.mpg
+lip/GRID/s17/lgayzn.mpg
+lip/GRID/s17/swig1s.mpg
+lip/GRID/s17/bbid3s.mpg
+lip/GRID/s9/pgbx7s.mpg
+lip/GRID/s9/prbi6n.mpg
+lip/GRID/s9/pbah8p.mpg
+lip/GRID/s9/sbas8n.mpg
+lip/GRID/s9/bbwz7a.mpg
+lip/GRID/s9/swah3s.mpg
+lip/GRID/s9/pbih4p.mpg
+lip/GRID/s9/lbip4p.mpg
+lip/GRID/s9/lwwz1s.mpg
+lip/GRID/s9/brbf7a.mpg
+lip/GRID/s9/bbbz3a.mpg
+lip/GRID/s9/sgbb8n.mpg
+lip/GRID/s9/pwbd1a.mpg
+lip/GRID/s9/pbibzp.mpg
+lip/GRID/s9/srwozp.mpg
+lip/GRID/s9/bbbl4p.mpg
+lip/GRID/s9/bgwh3a.mpg
+lip/GRID/s9/pbwi5s.mpg
+lip/GRID/s9/lwix8n.mpg
+lip/GRID/s9/brafzn.mpg
+lip/GRID/s9/sbif9a.mpg
+lip/GRID/s9/pwwj8p.mpg
+lip/GRID/s9/brwgzp.mpg
+lip/GRID/s9/pgic6n.mpg
+lip/GRID/s9/lrix3s.mpg
+lip/GRID/s9/prwj3a.mpg
+lip/GRID/s9/lwix9s.mpg
+lip/GRID/s9/lbbj9a.mpg
+lip/GRID/s9/srbt8n.mpg
+lip/GRID/s9/bgbt4n.mpg
+lip/GRID/s9/srbu1a.mpg
+lip/GRID/s9/pravzn.mpg
+lip/GRID/s9/swit6n.mpg
+lip/GRID/s9/sgib1s.mpg
+lip/GRID/s9/pgax3s.mpg
+lip/GRID/s9/swia7a.mpg
+lip/GRID/s9/sgiozp.mpg
+lip/GRID/s9/bbie2p.mpg
+lip/GRID/s9/bbay9a.mpg
+lip/GRID/s9/sbbnzp.mpg
+lip/GRID/s9/lrby3a.mpg
+lip/GRID/s9/bbiy4p.mpg
+lip/GRID/s9/bbbr9a.mpg
+lip/GRID/s9/pwiv5a.mpg
+lip/GRID/s9/sgib2p.mpg
+lip/GRID/s9/sgih7a.mpg
+lip/GRID/s9/lrij4n.mpg
+lip/GRID/s9/pwwj7s.mpg
+lip/GRID/s9/bgbg7s.mpg
+lip/GRID/s9/swwo6p.mpg
+lip/GRID/s9/sraa5a.mpg
+lip/GRID/s9/sgih5s.mpg
+lip/GRID/s9/bbbz2p.mpg
+lip/GRID/s9/bral6p.mpg
+lip/GRID/s9/sbbt4p.mpg
+lip/GRID/s9/pwbj5a.mpg
+lip/GRID/s9/pwwd2n.mpg
+lip/GRID/s9/lwbe5s.mpg
+lip/GRID/s9/bras1a.mpg
+lip/GRID/s9/lrbk5a.mpg
+lip/GRID/s9/lrbq7s.mpg
+lip/GRID/s9/lgae7s.mpg
+lip/GRID/s9/bwis3a.mpg
+lip/GRID/s9/lway4p.mpg
+lip/GRID/s9/sgiu3s.mpg
+lip/GRID/s9/bbae4n.mpg
+lip/GRID/s9/bbwl6n.mpg
+lip/GRID/s9/pgix1a.mpg
+lip/GRID/s9/lwbl1a.mpg
+lip/GRID/s9/lbbx6p.mpg
+lip/GRID/s9/srig5a.mpg
+lip/GRID/s9/bwil7s.mpg
+lip/GRID/s9/lgae9a.mpg
+lip/GRID/s9/bgam9a.mpg
+lip/GRID/s9/bgigzp.mpg
+lip/GRID/s9/lwbr2n.mpg
+lip/GRID/s9/prbv7a.mpg
+lip/GRID/s9/pgic7s.mpg
+lip/GRID/s9/sbwt8p.mpg
+lip/GRID/s9/bwif2n.mpg
+lip/GRID/s9/sgao2n.mpg
+lip/GRID/s9/pgiv9s.mpg
+lip/GRID/s9/priu9a.mpg
+lip/GRID/s9/swbu7a.mpg
+lip/GRID/s9/lbbx4n.mpg
+lip/GRID/s9/lwiy1a.mpg
+lip/GRID/s9/pgad1s.mpg
+lip/GRID/s9/pbwi4n.mpg
+lip/GRID/s9/pwbj3s.mpg
+lip/GRID/s9/srbuzp.mpg
+lip/GRID/s9/sbwn2n.mpg
+lip/GRID/s9/lbap8p.mpg
+lip/GRID/s9/bbbr7s.mpg
+lip/GRID/s9/pgwk3s.mpg
+lip/GRID/s9/pbbb6n.mpg
+lip/GRID/s9/bbbr8p.mpg
+lip/GRID/s9/bgwn4n.mpg
+lip/GRID/s9/lway5a.mpg
+lip/GRID/s9/brwm2n.mpg
+lip/GRID/s9/lrbk2n.mpg
+lip/GRID/s9/sgab6p.mpg
+lip/GRID/s9/swwi2p.mpg
+lip/GRID/s9/swin5a.mpg
+lip/GRID/s9/lbip2n.mpg
+lip/GRID/s9/lbaxzn.mpg
+lip/GRID/s9/brie8p.mpg
+lip/GRID/s9/lgwz7s.mpg
+lip/GRID/s9/brws8p.mpg
+lip/GRID/s9/lrad4n.mpg
+lip/GRID/s9/lbwq5s.mpg
+lip/GRID/s9/pbbvzp.mpg
+lip/GRID/s9/lwwl2n.mpg
+lip/GRID/s9/sbas9s.mpg
+lip/GRID/s9/sbis6p.mpg
+lip/GRID/s9/lgbf2p.mpg
+lip/GRID/s9/sbimzn.mpg
+lip/GRID/s9/bwwa3a.mpg
+lip/GRID/s9/pgwd9s.mpg
+lip/GRID/s9/pwio9s.mpg
+lip/GRID/s9/bbak8n.mpg
+lip/GRID/s9/lrwrzn.mpg
+lip/GRID/s9/lwwr9a.mpg
+lip/GRID/s9/swau3a.mpg
+lip/GRID/s9/brizzp.mpg
+lip/GRID/s9/pbwo9s.mpg
+lip/GRID/s9/srig4p.mpg
+lip/GRID/s9/bgag3s.mpg
+lip/GRID/s9/lwaq9s.mpg
+lip/GRID/s9/braz5a.mpg
+lip/GRID/s9/prwp6p.mpg
+lip/GRID/s9/lgwz8p.mpg
+lip/GRID/s9/sgai1a.mpg
+lip/GRID/s9/bbiq8n.mpg
+lip/GRID/s9/lrwy5s.mpg
+lip/GRID/s9/lrbk3s.mpg
+lip/GRID/s9/bbbl5a.mpg
+lip/GRID/s9/lrwr2p.mpg
+lip/GRID/s9/bwas5s.mpg
+lip/GRID/s9/bbik6p.mpg
+lip/GRID/s9/srwn9s.mpg
+lip/GRID/s9/pgwy1s.mpg
+lip/GRID/s9/lriqzp.mpg
+lip/GRID/s9/pbau7a.mpg
+lip/GRID/s9/srbn7a.mpg
+lip/GRID/s9/lgbz5a.mpg
+lip/GRID/s9/pwav9a.mpg
+lip/GRID/s9/bwam3a.mpg
+lip/GRID/s9/sbwh1a.mpg
+lip/GRID/s9/lwbe4n.mpg
+lip/GRID/s9/prih9s.mpg
+lip/GRID/s9/srwu2n.mpg
+lip/GRID/s9/sgau6n.mpg
+lip/GRID/s9/sbbn1a.mpg
+lip/GRID/s9/swbb5a.mpg
+lip/GRID/s9/bwbt1a.mpg
+lip/GRID/s9/bwwg5s.mpg
+lip/GRID/s9/lwby7s.mpg
+lip/GRID/s9/lgbf1s.mpg
+lip/GRID/s9/braszp.mpg
+lip/GRID/s9/sbam7a.mpg
+lip/GRID/s9/lrwk7s.mpg
+lip/GRID/s9/lbic4n.mpg
+lip/GRID/s9/sbat1a.mpg
+lip/GRID/s9/prbv6p.mpg
+lip/GRID/s9/prbp3a.mpg
+lip/GRID/s9/sgwv6p.mpg
+lip/GRID/s9/braf1s.mpg
+lip/GRID/s9/lrwk8p.mpg
+lip/GRID/s9/briy8n.mpg
+lip/GRID/s9/lgir1s.mpg
+lip/GRID/s9/bgim3s.mpg
+lip/GRID/s9/sgih6p.mpg
+lip/GRID/s9/lway3s.mpg
+lip/GRID/s9/swia6p.mpg
+lip/GRID/s9/pbia9s.mpg
+lip/GRID/s9/sbbg4n.mpg
+lip/GRID/s9/bgwt8n.mpg
+lip/GRID/s9/pbah7s.mpg
+lip/GRID/s9/pwbxzn.mpg
+lip/GRID/s9/pbin7s.mpg
+lip/GRID/s9/sgio1a.mpg
+lip/GRID/s9/srwb3a.mpg
+lip/GRID/s9/lgbl7a.mpg
+lip/GRID/s9/pgad3a.mpg
+lip/GRID/s9/bwas4n.mpg
+lip/GRID/s9/bgwh2p.mpg
+lip/GRID/s9/bbar5a.mpg
+lip/GRID/s9/brwf8n.mpg
+lip/GRID/s9/sgwc3s.mpg
+lip/GRID/s9/prbpzn.mpg
+lip/GRID/s9/pbao3a.mpg
+lip/GRID/s9/bwwg4n.mpg
+lip/GRID/s9/lrad6p.mpg
+lip/GRID/s9/lwid6n.mpg
+lip/GRID/s9/lrax8p.mpg
+lip/GRID/s9/pbib1a.mpg
+lip/GRID/s9/bbae6p.mpg
+lip/GRID/s9/bwbm5s.mpg
+lip/GRID/s9/bwbgzn.mpg
+lip/GRID/s9/lbiv8p.mpg
+lip/GRID/s9/lbaj2n.mpg
+lip/GRID/s9/swwo5s.mpg
+lip/GRID/s9/brie9a.mpg
+lip/GRID/s9/pwwx6p.mpg
+lip/GRID/s9/lgik8p.mpg
+lip/GRID/s9/lgwf7a.mpg
+lip/GRID/s9/srwh4n.mpg
+lip/GRID/s9/bgwa9a.mpg
+lip/GRID/s9/swah2n.mpg
+lip/GRID/s9/lwwl4p.mpg
+lip/GRID/s9/lgiy7a.mpg
+lip/GRID/s9/bgbn3a.mpg
+lip/GRID/s9/lwid9a.mpg
+lip/GRID/s9/swwu9s.mpg
+lip/GRID/s9/pgwezp.mpg
+lip/GRID/s9/swbozn.mpg
+lip/GRID/s9/pgbx9a.mpg
+lip/GRID/s9/brwg1a.mpg
+lip/GRID/s9/pbbizn.mpg
+lip/GRID/s9/lrad7a.mpg
+lip/GRID/s9/lgie4p.mpg
+lip/GRID/s9/prai4p.mpg
+lip/GRID/s9/sgbb9s.mpg
+lip/GRID/s9/lwwz3a.mpg
+lip/GRID/s9/lrwr3a.mpg
+lip/GRID/s9/sbbg6p.mpg
+lip/GRID/s9/lgws4p.mpg
+lip/GRID/s9/lbap9a.mpg
+lip/GRID/s9/bbik5s.mpg
+lip/GRID/s9/lgiy5s.mpg
+lip/GRID/s9/sbam6p.mpg
+lip/GRID/s9/prib6p.mpg
+lip/GRID/s9/lgwz6n.mpg
+lip/GRID/s9/pwiv4p.mpg
+lip/GRID/s9/bwiz4n.mpg
+lip/GRID/s9/swbu5s.mpg
+lip/GRID/s9/sgbi3s.mpg
+lip/GRID/s9/sgin9s.mpg
+lip/GRID/s9/pgax4p.mpg
+lip/GRID/s9/bwaz9s.mpg
+lip/GRID/s9/pbih2n.mpg
+lip/GRID/s9/lbiv9a.mpg
+lip/GRID/s9/lrbk4p.mpg
+lip/GRID/s9/bwas7a.mpg
+lip/GRID/s9/lrwy4n.mpg
+lip/GRID/s9/lbac9s.mpg
+lip/GRID/s9/brbmzp.mpg
+lip/GRID/s9/swwb8p.mpg
+lip/GRID/s9/lwiyzp.mpg
+lip/GRID/s9/lwwl5a.mpg
+lip/GRID/s9/pgbx8p.mpg
+lip/GRID/s9/sgiu5a.mpg
+lip/GRID/s9/pgwk5a.mpg
+lip/GRID/s9/lbbd5a.mpg
+lip/GRID/s9/bgatzn.mpg
+lip/GRID/s30/lgwq1n.mpg
+lip/GRID/s30/bbio7n.mpg
+lip/GRID/s30/prwa6s.mpg
+lip/GRID/s30/lgac8a.mpg
+lip/GRID/s30/bbbdza.mpg
+lip/GRID/s30/pgan9p.mpg
+lip/GRID/s30/swbf7p.mpg
+lip/GRID/s30/pgbu7p.mpg
+lip/GRID/s30/sralzs.mpg
+lip/GRID/s30/sbiyza.mpg
+lip/GRID/s30/bwakzs.mpg
+lip/GRID/s30/bbav6s.mpg
+lip/GRID/s30/sbbk7n.mpg
+lip/GRID/s30/brap9p.mpg
+lip/GRID/s30/bwwr4a.mpg
+lip/GRID/s30/bbipza.mpg
+lip/GRID/s30/pwia1p.mpg
+lip/GRID/s30/brbq2s.mpg
+lip/GRID/s30/bbap1n.mpg
+lip/GRID/s30/pwbh1n.mpg
+lip/GRID/s30/lwib6s.mpg
+lip/GRID/s30/bwij8a.mpg
+lip/GRID/s30/lrao4a.mpg
+lip/GRID/s30/bgik1n.mpg
+lip/GRID/s30/sgbtzs.mpg
+lip/GRID/s30/bgwz3p.mpg
+lip/GRID/s30/pgbh8s.mpg
+lip/GRID/s30/lwbc4s.mpg
+lip/GRID/s30/sbbr2s.mpg
+lip/GRID/s30/lgbx1n.mpg
+lip/GRID/s30/pgia5n.mpg
+lip/GRID/s30/lgbp9p.mpg
+lip/GRID/s30/pwwu4s.mpg
+lip/GRID/s30/lbau2a.mpg
+lip/GRID/s30/lbah3p.mpg
+lip/GRID/s30/lbwb6s.mpg
+lip/GRID/s30/bgak7p.mpg
+lip/GRID/s30/pbamzs.mpg
+lip/GRID/s30/srie1n.mpg
+lip/GRID/s30/lbin3p.mpg
+lip/GRID/s30/lgipzs.mpg
+lip/GRID/s30/sbbk9p.mpg
+lip/GRID/s30/pbwa2a.mpg
+lip/GRID/s30/bgarzs.mpg
+lip/GRID/s30/lbwo4s.mpg
+lip/GRID/s30/bbiv3p.mpg
+lip/GRID/s30/bwwe6a.mpg
+lip/GRID/s30/lraiza.mpg
+lip/GRID/s30/pwig3n.mpg
+lip/GRID/s30/pbaf8a.mpg
+lip/GRID/s30/lrab6a.mpg
+lip/GRID/s30/swaz3n.mpg
+lip/GRID/s30/pris6s.mpg
+lip/GRID/s30/lwbp3p.mpg
+lip/GRID/s30/lgwd6a.mpg
+lip/GRID/s30/swwm5p.mpg
+lip/GRID/s30/brax2s.mpg
+lip/GRID/s30/prim1n.mpg
+lip/GRID/s30/lbbh5n.mpg
+lip/GRID/s30/lwwc8s.mpg
+lip/GRID/s30/sgbg4a.mpg
+lip/GRID/s30/sral2a.mpg
+lip/GRID/s30/sgimza.mpg
+lip/GRID/s30/prba3p.mpg
+lip/GRID/s30/lgbj5p.mpg
+lip/GRID/s30/srwf6a.mpg
+lip/GRID/s30/swiy9n.mpg
+lip/GRID/s30/pgbu5n.mpg
+lip/GRID/s30/lribzs.mpg
+lip/GRID/s30/swbs6a.mpg
+lip/GRID/s30/lwiu9p.mpg
+lip/GRID/s30/bgwf2a.mpg
+lip/GRID/s30/pbwnza.mpg
+lip/GRID/s30/pbbm5p.mpg
+lip/GRID/s30/sbwr7p.mpg
+lip/GRID/s30/sgbm6s.mpg
+lip/GRID/s30/swaf1n.mpg
+lip/GRID/s30/bgwz2s.mpg
+lip/GRID/s30/bwwy6s.mpg
+lip/GRID/s30/bwbq8s.mpg
+lip/GRID/s30/sgwt5p.mpg
+lip/GRID/s30/srazza.mpg
+lip/GRID/s30/swie9p.mpg
+lip/GRID/s30/pgau3p.mpg
+lip/GRID/s30/sgbaza.mpg
+lip/GRID/s30/brij1p.mpg
+lip/GRID/s30/srak9n.mpg
+lip/GRID/s30/swil4a.mpg
+lip/GRID/s30/bwiq2a.mpg
+lip/GRID/s30/sgas5n.mpg
+lip/GRID/s30/pgbo3p.mpg
+lip/GRID/s30/lgbj6a.mpg
+lip/GRID/s30/lbig9p.mpg
+lip/GRID/s30/bwwr2s.mpg
+lip/GRID/s30/bgwr9p.mpg
+lip/GRID/s30/brbd4s.mpg
+lip/GRID/s30/lrwp1p.mpg
+lip/GRID/s30/brwq8a.mpg
+lip/GRID/s30/lriu4a.mpg
+lip/GRID/s30/lbbo1p.mpg
+lip/GRID/s30/bwwy7p.mpg
+lip/GRID/s30/sgwn2a.mpg
+lip/GRID/s30/pgbh9p.mpg
+lip/GRID/s30/pwag7n.mpg
+lip/GRID/s30/pgih1p.mpg
+lip/GRID/s30/lrwi7p.mpg
+lip/GRID/s30/swbs3n.mpg
+lip/GRID/s30/lgip2a.mpg
+lip/GRID/s30/pgbb6a.mpg
+lip/GRID/s30/pwan1n.mpg
+lip/GRID/s30/pwbh4a.mpg
+lip/GRID/s30/prim3p.mpg
+lip/GRID/s30/pwbh2s.mpg
+lip/GRID/s30/brwd8s.mpg
+lip/GRID/s30/bbac4s.mpg
+lip/GRID/s30/lrab3n.mpg
+lip/GRID/s30/sbae2a.mpg
+lip/GRID/s30/pbwg6a.mpg
+lip/GRID/s30/swaszs.mpg
+lip/GRID/s30/lrwi8a.mpg
+lip/GRID/s30/bgiq7p.mpg
+lip/GRID/s30/pgit7n.mpg
+lip/GRID/s30/pwat7p.mpg
+lip/GRID/s30/bwad6s.mpg
+lip/GRID/s30/pgwi1n.mpg
+lip/GRID/s30/brwy1p.mpg
+lip/GRID/s30/lwbp4a.mpg
+lip/GRID/s30/brwq6s.mpg
+lip/GRID/s30/lrwv6a.mpg
+lip/GRID/s30/brip6a.mpg
+lip/GRID/s30/swifza.mpg
+lip/GRID/s30/lwwdza.mpg
+lip/GRID/s30/sbij9n.mpg
+lip/GRID/s30/sbix7n.mpg
+lip/GRID/s30/bwid3p.mpg
+lip/GRID/s30/brbd3n.mpg
+lip/GRID/s30/lwwj4a.mpg
+lip/GRID/s30/bgik4a.mpg
+lip/GRID/s30/swbz8s.mpg
+lip/GRID/s30/sbik1p.mpg
+lip/GRID/s30/sgil8s.mpg
+lip/GRID/s30/pram6s.mpg
+lip/GRID/s30/lbig8s.mpg
+lip/GRID/s30/brbx6s.mpg
+lip/GRID/s30/pbbg2a.mpg
+lip/GRID/s30/prwuza.mpg
+lip/GRID/s30/swil2s.mpg
+lip/GRID/s30/lban7p.mpg
+lip/GRID/s30/lgii8a.mpg
+lip/GRID/s30/swaz6a.mpg
+lip/GRID/s30/pbbs8s.mpg
+lip/GRID/s30/bgae4a.mpg
+lip/GRID/s30/prif9p.mpg
+lip/GRID/s30/lgaj2a.mpg
+lip/GRID/s30/bwiq1p.mpg
+lip/GRID/s30/pwwh7p.mpg
+lip/GRID/s30/lbaa8s.mpg
+lip/GRID/s30/brwq5n.mpg
+lip/GRID/s30/lrbi1n.mpg
+lip/GRID/s30/lrwv5p.mpg
+lip/GRID/s30/lbaa9p.mpg
+lip/GRID/s30/bgak5n.mpg
+lip/GRID/s30/lbbh7p.mpg
+lip/GRID/s30/lrab4s.mpg
+lip/GRID/s30/lrbb8s.mpg
+lip/GRID/s30/pbil6s.mpg
+lip/GRID/s30/pbbs7n.mpg
+lip/GRID/s30/pgbb5p.mpg
+lip/GRID/s30/srar4s.mpg
+lip/GRID/s30/bgiq8a.mpg
+lip/GRID/s30/pbbtza.mpg
+lip/GRID/s30/lwio6a.mpg
+lip/GRID/s30/briv9p.mpg
+lip/GRID/s30/srar5p.mpg
+lip/GRID/s30/lbit7p.mpg
+lip/GRID/s30/lrin8s.mpg
+lip/GRID/s30/swbs5p.mpg
+lip/GRID/s30/pbas4s.mpg
+lip/GRID/s30/sbwy9n.mpg
+lip/GRID/s30/prigza.mpg
+lip/GRID/s30/lbwb5n.mpg
+lip/GRID/s30/sgis4a.mpg
+lip/GRID/s30/brwd9p.mpg
+lip/GRID/s30/sgif6a.mpg
+lip/GRID/s30/lrib1p.mpg
+lip/GRID/s30/prwt8s.mpg
+lip/GRID/s30/lbwi2a.mpg
+lip/GRID/s30/prbg7p.mpg
+lip/GRID/s30/lrbv1p.mpg
+lip/GRID/s30/sgbt1p.mpg
+lip/GRID/s30/bbbc8s.mpg
+lip/GRID/s30/bradzs.mpg
+lip/GRID/s30/bgiq5n.mpg
+lip/GRID/s30/brad1p.mpg
+lip/GRID/s30/pwwh8a.mpg
+lip/GRID/s30/brax1n.mpg
+lip/GRID/s30/brip5p.mpg
+lip/GRID/s30/lgiv3n.mpg
+lip/GRID/s30/sbwl4a.mpg
+lip/GRID/s30/sbwe9p.mpg
+lip/GRID/s30/brwk2s.mpg
+lip/GRID/s30/swws7n.mpg
+lip/GRID/s30/bwad7p.mpg
+lip/GRID/s30/pgbh7n.mpg
+lip/GRID/s30/pgiuza.mpg
+lip/GRID/s30/lwav4a.mpg
+lip/GRID/s30/lbwvza.mpg
+lip/GRID/s30/pgah5p.mpg
+lip/GRID/s30/lbig7n.mpg
+lip/GRID/s30/lbin2s.mpg
+lip/GRID/s30/swie7n.mpg
+lip/GRID/s30/brax3p.mpg
+lip/GRID/s30/srwl7n.mpg
+lip/GRID/s30/sgwa4a.mpg
+lip/GRID/s30/lgbqza.mpg
+lip/GRID/s30/sgbm8a.mpg
+lip/GRID/s30/sriq9n.mpg
+lip/GRID/s30/sgaf7n.mpg
+lip/GRID/s30/pwwu5p.mpg
+lip/GRID/s30/lbia4s.mpg
+lip/GRID/s30/bbii3n.mpg
+lip/GRID/s30/brbj7n.mpg
+lip/GRID/s30/pris5n.mpg
+lip/GRID/s30/pgan7n.mpg
+lip/GRID/s30/pbas6a.mpg
+lip/GRID/s30/bbii4s.mpg
+lip/GRID/s30/lbbozs.mpg
+lip/GRID/s30/lriu2s.mpg
+lip/GRID/s30/bgwe9n.mpg
+lip/GRID/s30/srie3p.mpg
+lip/GRID/s30/pbaf5n.mpg
+lip/GRID/s30/pwit4a.mpg
+lip/GRID/s30/lrioza.mpg
+lip/GRID/s30/pgia7p.mpg
+lip/GRID/s30/sbwr8a.mpg
+lip/GRID/s30/bwbezs.mpg
+lip/GRID/s30/lrbi2s.mpg
+lip/GRID/s30/lgiv6a.mpg
+lip/GRID/s30/sbbe3n.mpg
+lip/GRID/s30/bwwe5p.mpg
+lip/GRID/s30/lgii5n.mpg
+lip/GRID/s30/srirzs.mpg
+lip/GRID/s30/sbwz1p.mpg
+lip/GRID/s30/lrwpzs.mpg
+lip/GRID/s30/lgwx5n.mpg
+lip/GRID/s30/bgby8s.mpg
+lip/GRID/s30/bbic2a.mpg
+lip/GRID/s30/sgil9p.mpg
+lip/GRID/s30/bbwj7p.mpg
+lip/GRID/s30/bgbe5n.mpg
+lip/GRID/s30/bbbp7p.mpg
+lip/GRID/s30/bgwz1n.mpg
+lip/GRID/s30/pgau1n.mpg
+lip/GRID/s30/swar9n.mpg
+lip/GRID/s30/bbwx5p.mpg
+lip/GRID/s34/lgwdzs.mpg
+lip/GRID/s34/lbim9p.mpg
+lip/GRID/s34/lbinza.mpg
+lip/GRID/s34/sbbezs.mpg
+lip/GRID/s34/brbj6a.mpg
+lip/GRID/s34/bwwrza.mpg
+lip/GRID/s34/lwavza.mpg
+lip/GRID/s34/sbaq5p.mpg
+lip/GRID/s34/prwt6a.mpg
+lip/GRID/s34/sbij8a.mpg
+lip/GRID/s34/lrbo2s.mpg
+lip/GRID/s34/pbbl9n.mpg
+lip/GRID/s34/srarzs.mpg
+lip/GRID/s34/sbwk7n.mpg
+lip/GRID/s34/lgbc6s.mpg
+lip/GRID/s34/pwat3p.mpg
+lip/GRID/s34/prwa1n.mpg
+lip/GRID/s34/pgaa7p.mpg
+lip/GRID/s34/lgbv7n.mpg
+lip/GRID/s34/bgayzs.mpg
+lip/GRID/s34/bwad1n.mpg
+lip/GRID/s34/swazzs.mpg
+lip/GRID/s34/bgaeza.mpg
+lip/GRID/s34/praz9n.mpg
+lip/GRID/s34/swbl8a.mpg
+lip/GRID/s34/swiy8a.mpg
+lip/GRID/s34/prwg7p.mpg
+lip/GRID/s34/sgws9n.mpg
+lip/GRID/s34/pbifza.mpg
+lip/GRID/s34/pbal5n.mpg
+lip/GRID/s34/pris2s.mpg
+lip/GRID/s34/sgaf6a.mpg
+lip/GRID/s34/bric3p.mpg
+lip/GRID/s34/lrig9n.mpg
+lip/GRID/s34/swir4a.mpg
+lip/GRID/s34/pgig6s.mpg
+lip/GRID/s34/sbiq1p.mpg
+lip/GRID/s34/srbe6s.mpg
+lip/GRID/s34/lgio5n.mpg
+lip/GRID/s34/braj1p.mpg
+lip/GRID/s34/lbbu1p.mpg
+lip/GRID/s34/srik1n.mpg
+lip/GRID/s34/lwwv7p.mpg
+lip/GRID/s34/bbao9p.mpg
+lip/GRID/s34/pwbg8s.mpg
+lip/GRID/s34/brwd3n.mpg
+lip/GRID/s34/pbir7p.mpg
+lip/GRID/s34/pwwh1n.mpg
+lip/GRID/s34/swie4s.mpg
+lip/GRID/s34/bbac1p.mpg
+lip/GRID/s34/lria8a.mpg
+lip/GRID/s34/lbit3p.mpg
+lip/GRID/s34/sbbk5p.mpg
+lip/GRID/s34/pwaa2a.mpg
+lip/GRID/s34/bwwq9p.mpg
+lip/GRID/s34/pgwb3n.mpg
+lip/GRID/s34/bbivza.mpg
+lip/GRID/s34/lgac3p.mpg
+lip/GRID/s34/bwwe2a.mpg
+lip/GRID/s34/swws6a.mpg
+lip/GRID/s34/lrin3n.mpg
+lip/GRID/s34/lrbo4a.mpg
+lip/GRID/s34/pgwu6s.mpg
+lip/GRID/s34/swws5p.mpg
+lip/GRID/s34/pwbt6s.mpg
+lip/GRID/s34/bwad2s.mpg
+lip/GRID/s34/swbl5n.mpg
+lip/GRID/s34/bbbc6a.mpg
+lip/GRID/s34/lrit8s.mpg
+lip/GRID/s34/swar8a.mpg
+lip/GRID/s34/pris3p.mpg
+lip/GRID/s34/bric4a.mpg
+lip/GRID/s34/bbai3n.mpg
+lip/GRID/s34/bgiq3p.mpg
+lip/GRID/s34/srby8s.mpg
+lip/GRID/s34/pwba6a.mpg
+lip/GRID/s34/sbwe6a.mpg
+lip/GRID/s34/sgisza.mpg
+lip/GRID/s34/lbaa6a.mpg
+lip/GRID/s34/lgwx2s.mpg
+lip/GRID/s34/pwam7n.mpg
+lip/GRID/s34/bwbx8s.mpg
+lip/GRID/s34/bbbp3p.mpg
+lip/GRID/s34/pbaz4s.mpg
+lip/GRID/s34/lbia2a.mpg
+lip/GRID/s34/swbl7p.mpg
+lip/GRID/s34/brbdzs.mpg
+lip/GRID/s34/prbg3p.mpg
+lip/GRID/s34/pwim3n.mpg
+lip/GRID/s34/lwao4s.mpg
+lip/GRID/s34/swiy6s.mpg
+lip/GRID/s34/sgiz4a.mpg
+lip/GRID/s34/bbwx1p.mpg
+lip/GRID/s34/pwim4s.mpg
+lip/GRID/s34/sgbm1n.mpg
+lip/GRID/s34/lgiv2a.mpg
+lip/GRID/s34/sbbd9n.mpg
+lip/GRID/s34/lbat7p.mpg
+lip/GRID/s34/swws4s.mpg
+lip/GRID/s34/lbbn5n.mpg
+lip/GRID/s34/lban4a.mpg
+lip/GRID/s34/bgij8s.mpg
+lip/GRID/s34/lran9p.mpg
+lip/GRID/s34/swwz8s.mpg
+lip/GRID/s34/srwfzs.mpg
+lip/GRID/s34/bwip8a.mpg
+lip/GRID/s34/lgbp4s.mpg
+lip/GRID/s34/bbbv6s.mpg
+lip/GRID/s34/sgwaza.mpg
+lip/GRID/s34/lrwv1p.mpg
+lip/GRID/s34/bgwr6a.mpg
+lip/GRID/s34/lgii2s.mpg
+lip/GRID/s34/lwwp1n.mpg
+lip/GRID/s34/prwn1p.mpg
+lip/GRID/s34/lbwb3p.mpg
+lip/GRID/s34/pwbn1n.mpg
+lip/GRID/s34/lwib3p.mpg
+lip/GRID/s34/bgid4s.mpg
+lip/GRID/s34/sbiqzs.mpg
+lip/GRID/s34/pbaf3p.mpg
+lip/GRID/s34/sgbs5n.mpg
+lip/GRID/s34/pbbs5p.mpg
+lip/GRID/s34/sgaz7p.mpg
+lip/GRID/s34/sgaf4s.mpg
+lip/GRID/s34/sbayza.mpg
+lip/GRID/s34/sbix6a.mpg
+lip/GRID/s34/bgwr5p.mpg
+lip/GRID/s34/bbwc8s.mpg
+lip/GRID/s34/bbav3p.mpg
+lip/GRID/s34/bwbd8a.mpg
+lip/GRID/s34/lrihzs.mpg
+lip/GRID/s34/sbid4a.mpg
+lip/GRID/s34/pgia2s.mpg
+lip/GRID/s34/bbib8a.mpg
+lip/GRID/s34/brajzs.mpg
+lip/GRID/s34/bgix7p.mpg
+lip/GRID/s34/bgwy8s.mpg
+lip/GRID/s34/pbwm5p.mpg
+lip/GRID/s34/prwnzs.mpg
+lip/GRID/s34/pbar9n.mpg
+lip/GRID/s34/pbaf2s.mpg
+lip/GRID/s34/pbal7p.mpg
+lip/GRID/s34/pgat8s.mpg
+lip/GRID/s34/prwa2s.mpg
+lip/GRID/s34/sgwm5n.mpg
+lip/GRID/s34/lria6s.mpg
+lip/GRID/s34/lrwb9p.mpg
+lip/GRID/s34/pgit3n.mpg
+lip/GRID/s34/pram3p.mpg
+lip/GRID/s34/pgig5n.mpg
+lip/GRID/s34/bbwc9p.mpg
+lip/GRID/s34/pgwu8a.mpg
+lip/GRID/s34/sgifzs.mpg
+lip/GRID/s34/swae9p.mpg
+lip/GRID/s34/bbwj1n.mpg
+lip/GRID/s34/sbbq8s.mpg
+lip/GRID/s34/pbbs3n.mpg
+lip/GRID/s34/pwba4s.mpg
+lip/GRID/s34/sbak2a.mpg
+lip/GRID/s34/swwf8a.mpg
+lip/GRID/s34/lbbuzs.mpg
+lip/GRID/s34/pgbu3p.mpg
+lip/GRID/s34/pbiz1p.mpg
+lip/GRID/s34/pbws9p.mpg
+lip/GRID/s34/lgwd1p.mpg
+lip/GRID/s34/sbiq2a.mpg
+lip/GRID/s34/bgbk8a.mpg
+lip/GRID/s34/sgaz6s.mpg
+lip/GRID/s34/bgwe8a.mpg
+lip/GRID/s34/bgwy7n.mpg
+lip/GRID/s34/bwbj9n.mpg
+lip/GRID/s34/lbwozs.mpg
+lip/GRID/s34/lbig5p.mpg
+lip/GRID/s34/swar7p.mpg
+lip/GRID/s34/brbj4s.mpg
+lip/GRID/s34/srid7n.mpg
+lip/GRID/s34/pwwh3p.mpg
+lip/GRID/s34/bwbq4s.mpg
+lip/GRID/s34/lran8s.mpg
+lip/GRID/s34/lwwp4a.mpg
+lip/GRID/s34/pbil3p.mpg
+lip/GRID/s34/pgbh5p.mpg
+lip/GRID/s34/pbie9p.mpg
+lip/GRID/s34/prbg2s.mpg
+lip/GRID/s34/lbwn9n.mpg
+lip/GRID/s34/bbib7p.mpg
+lip/GRID/s34/bbbc4s.mpg
+lip/GRID/s34/lwwi9p.mpg
+lip/GRID/s34/pram2s.mpg
+lip/GRID/s34/bwwk5p.mpg
+lip/GRID/s34/swae7n.mpg
+lip/GRID/s34/bgiq1n.mpg
+lip/GRID/s34/lwwv5n.mpg
+lip/GRID/s34/pras6s.mpg
+lip/GRID/s34/pgaa5n.mpg
+lip/GRID/s34/pras5n.mpg
+lip/GRID/s34/pgwb4s.mpg
+lip/GRID/s34/prbaza.mpg
+lip/GRID/s34/sgwg1n.mpg
+lip/GRID/s34/bbib5n.mpg
+lip/GRID/s34/brbc9n.mpg
+lip/GRID/s34/primza.mpg
+lip/GRID/s34/pbwm6a.mpg
+lip/GRID/s34/lrbo1n.mpg
+lip/GRID/s34/prbtzs.mpg
+lip/GRID/s34/sbbe2a.mpg
+lip/GRID/s34/srwsza.mpg
+lip/GRID/s34/pbie7n.mpg
+lip/GRID/s34/lwih7p.mpg
+lip/GRID/s34/lwau9p.mpg
+lip/GRID/s34/pgwo4a.mpg
+lip/GRID/s34/bgaq8a.mpg
+lip/GRID/s34/lgii3p.mpg
+lip/GRID/s34/lwai1p.mpg
+lip/GRID/s34/pgwh8s.mpg
+lip/GRID/s34/bwbq3n.mpg
+lip/GRID/s34/lgicza.mpg
+lip/GRID/s34/pwanza.mpg
+lip/GRID/s34/pgit4s.mpg
+lip/GRID/s34/srbr6a.mpg
+lip/GRID/s34/lgav5p.mpg
+lip/GRID/s34/lgbj2a.mpg
+lip/GRID/s34/swwm1p.mpg
+lip/GRID/s34/srby7n.mpg
+lip/GRID/s34/swal3p.mpg
+lip/GRID/s34/briv3n.mpg
+lip/GRID/s34/bgwr3n.mpg
+lip/GRID/s34/swar5n.mpg
+lip/GRID/s34/lbwu6a.mpg
+lip/GRID/s34/lwbv1n.mpg
+lip/GRID/s34/bwij4a.mpg
+lip/GRID/s34/lwbi3n.mpg
+lip/GRID/s34/bbbc3n.mpg
+lip/GRID/s34/sriy2a.mpg
+lip/GRID/s34/lrah6a.mpg
+lip/GRID/s34/brac7p.mpg
+lip/GRID/s34/lwaizs.mpg
+lip/GRID/s34/bbiu7n.mpg
+lip/GRID/s34/bgwr4s.mpg
+lip/GRID/s34/pgwiza.mpg
+lip/GRID/s34/sgif1p.mpg
+lip/GRID/s34/bbai6a.mpg
+lip/GRID/s34/swws3n.mpg
+lip/GRID/s34/bbai4s.mpg
+lip/GRID/s34/bbwp6s.mpg
+lip/GRID/s34/sgbgza.mpg
+lip/GRID/s34/lgai6s.mpg
+lip/GRID/s34/lbig4s.mpg
+lip/GRID/s34/bgax9n.mpg
+lip/GRID/s34/brwq1n.mpg
+lip/GRID/s34/bgwy9p.mpg
+lip/GRID/s34/pbaf4a.mpg
+lip/GRID/s34/bgiq2s.mpg
+lip/GRID/s34/pbie8s.mpg
+lip/GRID/s34/lrbb4s.mpg
+lip/GRID/s25/lrib7a.mpg
+lip/GRID/s25/lgax5a.mpg
+lip/GRID/s25/lgbx9a.mpg
+lip/GRID/s25/pwwb7s.mpg
+lip/GRID/s25/pwbh8p.mpg
+lip/GRID/s25/bbbj8p.mpg
+lip/GRID/s25/brwy5s.mpg
+lip/GRID/s25/lgij2p.mpg
+lip/GRID/s25/sgat1s.mpg
+lip/GRID/s25/lgbq4p.mpg
+lip/GRID/s25/bgir3a.mpg
+lip/GRID/s25/sgis8p.mpg
+lip/GRID/s25/pgwc3s.mpg
+lip/GRID/s25/bgay9s.mpg
+lip/GRID/s25/lwav9a.mpg
+lip/GRID/s25/braq4p.mpg
+lip/GRID/s25/bgbl6p.mpg
+lip/GRID/s25/sbws2p.mpg
+lip/GRID/s25/pwbb2n.mpg
+lip/GRID/s25/lwai9s.mpg
+lip/GRID/s25/sril3a.mpg
+lip/GRID/s25/bgwz7s.mpg
+lip/GRID/s25/sgat3a.mpg
+lip/GRID/s25/pwau3a.mpg
+lip/GRID/s25/sbwl7s.mpg
+lip/GRID/s25/sbie2p.mpg
+lip/GRID/s25/pgao5a.mpg
+lip/GRID/s25/srir7a.mpg
+lip/GRID/s25/lwiv2n.mpg
+lip/GRID/s25/pgbi3s.mpg
+lip/GRID/s25/praa2n.mpg
+lip/GRID/s25/lrih9s.mpg
+lip/GRID/s25/sgbg9a.mpg
+lip/GRID/s25/srbl8n.mpg
+lip/GRID/s25/bgwmzp.mpg
+lip/GRID/s25/lgiv9s.mpg
+lip/GRID/s25/bwwzzn.mpg
+lip/GRID/s25/sbws3a.mpg
+lip/GRID/s25/lwbj2n.mpg
+lip/GRID/s25/brak1a.mpg
+lip/GRID/s25/lbia9s.mpg
+lip/GRID/s25/lwwd5a.mpg
+lip/GRID/s25/lrwp6p.mpg
+lip/GRID/s25/pbis7a.mpg
+lip/GRID/s25/lwiv5a.mpg
+lip/GRID/s25/sbwz5s.mpg
+lip/GRID/s25/bgwf6p.mpg
+lip/GRID/s25/srilzn.mpg
+lip/GRID/s25/bbbj9a.mpg
+lip/GRID/s25/pgwv6p.mpg
+lip/GRID/s25/bbad1a.mpg
+lip/GRID/s25/pgbv1s.mpg
+lip/GRID/s25/lbih2n.mpg
+lip/GRID/s25/swbm5s.mpg
+lip/GRID/s25/pgab5s.mpg
+lip/GRID/s25/bbap7s.mpg
+lip/GRID/s25/srie7s.mpg
+lip/GRID/s25/sbwl8p.mpg
+lip/GRID/s25/lbib1a.mpg
+lip/GRID/s25/lwbp6n.mpg
+lip/GRID/s25/lbbo7a.mpg
+lip/GRID/s25/lwwx6p.mpg
+lip/GRID/s25/pgbv3a.mpg
+lip/GRID/s25/pbim1s.mpg
+lip/GRID/s25/lrwc8p.mpg
+lip/GRID/s25/sgag2n.mpg
+lip/GRID/s25/pgwi8p.mpg
+lip/GRID/s25/bbbq2p.mpg
+lip/GRID/s25/lrwx1a.mpg
+lip/GRID/s25/sgis7s.mpg
+lip/GRID/s25/bway5a.mpg
+lip/GRID/s25/bgwm1a.mpg
+lip/GRID/s25/pbwt9a.mpg
+lip/GRID/s25/prbh1s.mpg
+lip/GRID/s25/pbbt3s.mpg
+lip/GRID/s25/swiszn.mpg
+lip/GRID/s25/prba8p.mpg
+lip/GRID/s25/lbwpzp.mpg
+lip/GRID/s25/sbbr8p.mpg
+lip/GRID/s25/bwwr9a.mpg
+lip/GRID/s25/srbf7a.mpg
+lip/GRID/s25/sbie3a.mpg
+lip/GRID/s25/bwaezn.mpg
+lip/GRID/s25/sgba5a.mpg
+lip/GRID/s25/bwaq9s.mpg
+lip/GRID/s25/pwit7s.mpg
+lip/GRID/s25/lgij3a.mpg
+lip/GRID/s25/pgio1a.mpg
+lip/GRID/s25/brij6p.mpg
+lip/GRID/s25/bbij1a.mpg
+lip/GRID/s25/srbm1a.mpg
+lip/GRID/s25/pgwv7a.mpg
+lip/GRID/s25/lrio3s.mpg
+lip/GRID/s25/swbgzn.mpg
+lip/GRID/s25/lravzn.mpg
+lip/GRID/s25/swiz4n.mpg
+lip/GRID/s25/swaz9s.mpg
+lip/GRID/s25/lbwo9s.mpg
+lip/GRID/s25/prwo1a.mpg
+lip/GRID/s25/bbwd9a.mpg
+lip/GRID/s25/sriz1a.mpg
+lip/GRID/s25/prbn4n.mpg
+lip/GRID/s25/srbl9s.mpg
+lip/GRID/s25/lgbx8p.mpg
+lip/GRID/s25/lrbi9a.mpg
+lip/GRID/s25/bgie3s.mpg
+lip/GRID/s25/prwu3s.mpg
+lip/GRID/s25/pwwi1s.mpg
+lip/GRID/s25/lwbc8n.mpg
+lip/GRID/s25/sbwf3s.mpg
+lip/GRID/s25/pwbh6n.mpg
+lip/GRID/s25/sgam9a.mpg
+lip/GRID/s25/sbik5s.mpg
+lip/GRID/s25/swbm6p.mpg
+lip/GRID/s25/lwbx2p.mpg
+lip/GRID/s25/pwin4p.mpg
+lip/GRID/s25/bbwq4n.mpg
+lip/GRID/s25/bbii8n.mpg
+lip/GRID/s25/sraf2p.mpg
+lip/GRID/s25/bbadzp.mpg
+lip/GRID/s25/bbwx8n.mpg
+lip/GRID/s25/sbiq9s.mpg
+lip/GRID/s25/swiz6p.mpg
+lip/GRID/s25/lbwv5a.mpg
+lip/GRID/s25/sral6p.mpg
+lip/GRID/s25/lriu7s.mpg
+lip/GRID/s25/lwac5s.mpg
+lip/GRID/s25/pranzn.mpg
+lip/GRID/s25/pwwb6n.mpg
+lip/GRID/s25/sbwz4n.mpg
+lip/GRID/s25/lrai4p.mpg
+lip/GRID/s25/pgwi6n.mpg
+lip/GRID/s25/bridzn.mpg
+lip/GRID/s25/lwwx5s.mpg
+lip/GRID/s25/bgbz4p.mpg
+lip/GRID/s25/pwwu9s.mpg
+lip/GRID/s25/lgic8p.mpg
+lip/GRID/s25/bbbd3s.mpg
+lip/GRID/s25/pwbu6p.mpg
+lip/GRID/s25/bgar4n.mpg
+lip/GRID/s25/swil8p.mpg
+lip/GRID/s25/sbiezn.mpg
+lip/GRID/s25/srwf9s.mpg
+lip/GRID/s25/sbbf1a.mpg
+lip/GRID/s25/bgirzn.mpg
+lip/GRID/s25/srir5s.mpg
+lip/GRID/s25/prwb2p.mpg
+lip/GRID/s25/pwbu7a.mpg
+lip/GRID/s25/lbwi5s.mpg
+lip/GRID/s25/lbbb9a.mpg
+lip/GRID/s25/brbk5a.mpg
+lip/GRID/s25/lwbj4p.mpg
+lip/GRID/s25/bwwz1s.mpg
+lip/GRID/s25/pbwhzp.mpg
+lip/GRID/s25/bgbl5s.mpg
+lip/GRID/s25/brix4p.mpg
+lip/GRID/s25/swwg5s.mpg
+lip/GRID/s25/lbin6n.mpg
+lip/GRID/s25/lwap4p.mpg
+lip/GRID/s25/lrwp4n.mpg
+lip/GRID/s25/brbk3s.mpg
+lip/GRID/s25/prwbzn.mpg
+lip/GRID/s25/sgba2n.mpg
+lip/GRID/s25/pbbnzp.mpg
+lip/GRID/s25/sgbt7a.mpg
+lip/GRID/s25/lbbv1a.mpg
+lip/GRID/s25/bgbfzn.mpg
+lip/GRID/s25/lwbx3a.mpg
+lip/GRID/s25/bgaz1a.mpg
+lip/GRID/s25/sgam8p.mpg
+lip/GRID/s25/bwwl3s.mpg
+lip/GRID/s25/lbbi1s.mpg
+lip/GRID/s25/sgbt6p.mpg
+lip/GRID/s25/swwt5a.mpg
+lip/GRID/s25/sras1a.mpg
+lip/GRID/s25/srwf8n.mpg
+lip/GRID/s25/bwik3a.mpg
+lip/GRID/s25/sriy9s.mpg
+lip/GRID/s25/lbin8p.mpg
+lip/GRID/s25/swis2p.mpg
+lip/GRID/s25/sgwh3a.mpg
+lip/GRID/s25/pbag1s.mpg
+lip/GRID/s25/srwg1a.mpg
+lip/GRID/s25/bbap9a.mpg
+lip/GRID/s25/pgah9s.mpg
+lip/GRID/s25/pwwv1a.mpg
+lip/GRID/s25/brwe2n.mpg
+lip/GRID/s25/lriu9a.mpg
+lip/GRID/s25/sgba4p.mpg
+lip/GRID/s25/sraz3s.mpg
+lip/GRID/s25/sbak9s.mpg
+lip/GRID/s25/bgik6n.mpg
+lip/GRID/s25/sgis6n.mpg
+lip/GRID/s25/lrbv4n.mpg
+lip/GRID/s25/lwwj6n.mpg
+lip/GRID/s25/brbq8p.mpg
+lip/GRID/s25/brax7s.mpg
+lip/GRID/s25/pbagzn.mpg
+lip/GRID/s25/praa4p.mpg
+lip/GRID/s25/lbab4p.mpg
+lip/GRID/s25/srbs2n.mpg
+lip/GRID/s25/lbwi4n.mpg
+lip/GRID/s25/sgwh1s.mpg
+lip/GRID/s25/sgbg7s.mpg
+lip/GRID/s25/prag7s.mpg
+lip/GRID/s25/pwit8p.mpg
+lip/GRID/s25/sgwn6p.mpg
+lip/GRID/s25/swwm9s.mpg
+lip/GRID/s25/pbiz8n.mpg
+lip/GRID/s25/pbif6n.mpg
+lip/GRID/s25/pbif9a.mpg
+lip/GRID/s25/lbwc1s.mpg
+lip/GRID/s25/briqzp.mpg
+lip/GRID/s25/lwwd3s.mpg
+lip/GRID/s25/pbwn4p.mpg
+lip/GRID/s25/sgbt4n.mpg
+lip/GRID/s25/swif3s.mpg
+lip/GRID/s25/bbwx9s.mpg
+lip/GRID/s25/bwak5s.mpg
+lip/GRID/s25/pbag2p.mpg
+lip/GRID/s25/pwin3s.mpg
+lip/GRID/s25/bgiy5s.mpg
+lip/GRID/s25/swbtzp.mpg
+lip/GRID/s25/swam3a.mpg
+lip/GRID/s25/srir4n.mpg
+lip/GRID/s25/lbau5s.mpg
+lip/GRID/s25/lbau6p.mpg
+lip/GRID/s25/bwarzp.mpg
+lip/GRID/s25/sgwu1a.mpg
+lip/GRID/s25/bwiyzp.mpg
+lip/GRID/s25/lgap8n.mpg
+lip/GRID/s25/lgwq9a.mpg
+lip/GRID/s25/swil7s.mpg
+lip/GRID/s25/swbg3a.mpg
+lip/GRID/s25/lrbv6p.mpg
+lip/GRID/s25/brid2p.mpg
+lip/GRID/s25/lgwq8p.mpg
+lip/GRID/s25/brad7a.mpg
+lip/GRID/s25/srwm3s.mpg
+lip/GRID/s25/pbim3a.mpg
+lip/GRID/s25/lbih3s.mpg
+lip/GRID/s25/sbwf2n.mpg
+lip/GRID/s25/pgbczp.mpg
+lip/GRID/s25/swwg6p.mpg
+lip/GRID/s25/lrwxzp.mpg
+lip/GRID/s25/swiz7a.mpg
+lip/GRID/s25/sbbr9a.mpg
+lip/GRID/s25/prbn5s.mpg
+lip/GRID/s25/pbis4n.mpg
+lip/GRID/s25/swif2n.mpg
+lip/GRID/s25/lbbb6n.mpg
+lip/GRID/s25/bbip5a.mpg
+lip/GRID/s25/brwk6n.mpg
+lip/GRID/s25/lwaj1a.mpg
+lip/GRID/s25/prwozp.mpg
+lip/GRID/s24/bbiv9p.mpg
+lip/GRID/s24/sgwuzs.mpg
+lip/GRID/s24/lbbvzs.mpg
+lip/GRID/s24/bbap9p.mpg
+lip/GRID/s24/bgbs1p.mpg
+lip/GRID/s24/lgiv9n.mpg
+lip/GRID/s24/lgic8s.mpg
+lip/GRID/s24/lwac6s.mpg
+lip/GRID/s24/sbwmza.mpg
+lip/GRID/s24/bwiq6s.mpg
+lip/GRID/s24/bgiy7p.mpg
+lip/GRID/s24/lbbb7n.mpg
+lip/GRID/s24/sbbr9p.mpg
+lip/GRID/s24/sgbn3p.mpg
+lip/GRID/s24/pgwc3n.mpg
+lip/GRID/s24/lraczs.mpg
+lip/GRID/s24/pwin3n.mpg
+lip/GRID/s24/lwap6a.mpg
+lip/GRID/s24/lbih4s.mpg
+lip/GRID/s24/lrbp2s.mpg
+lip/GRID/s24/bbwq5n.mpg
+lip/GRID/s24/brad7p.mpg
+lip/GRID/s24/lbin9p.mpg
+lip/GRID/s24/sgitza.mpg
+lip/GRID/s24/bwieza.mpg
+lip/GRID/s24/lwiv5p.mpg
+lip/GRID/s24/bbwyzs.mpg
+lip/GRID/s24/brbrza.mpg
+lip/GRID/s24/pbam5n.mpg
+lip/GRID/s24/pgah9n.mpg
+lip/GRID/s24/lbah9p.mpg
+lip/GRID/s24/sbbr8s.mpg
+lip/GRID/s24/lbbb9p.mpg
+lip/GRID/s24/pwit7n.mpg
+lip/GRID/s24/sbazza.mpg
+lip/GRID/s24/bwwe9n.mpg
+lip/GRID/s24/sgwu1p.mpg
+lip/GRID/s24/brid2s.mpg
+lip/GRID/s24/bwbk9n.mpg
+lip/GRID/s24/srbm1p.mpg
+lip/GRID/s24/pwbh8s.mpg
+lip/GRID/s24/lgbq3n.mpg
+lip/GRID/s24/brwr3p.mpg
+lip/GRID/s24/bbbq1n.mpg
+lip/GRID/s24/pbag1n.mpg
+lip/GRID/s24/pgbv3p.mpg
+lip/GRID/s24/lrib6s.mpg
+lip/GRID/s24/lgbx8s.mpg
+lip/GRID/s24/brix4s.mpg
+lip/GRID/s24/brid4a.mpg
+lip/GRID/s24/lrao8s.mpg
+lip/GRID/s24/sgbt6s.mpg
+lip/GRID/s24/lgwy3p.mpg
+lip/GRID/s24/sbik7p.mpg
+lip/GRID/s24/lgbx7n.mpg
+lip/GRID/s24/sbar3n.mpg
+lip/GRID/s24/sbae5n.mpg
+lip/GRID/s24/pwiuza.mpg
+lip/GRID/s24/sriy9n.mpg
+lip/GRID/s24/pgib4a.mpg
+lip/GRID/s24/lwii8a.mpg
+lip/GRID/s24/swam4a.mpg
+lip/GRID/s24/brwy6s.mpg
+lip/GRID/s24/sbwz6s.mpg
+lip/GRID/s24/lbao4a.mpg
+lip/GRID/s24/bwwz3p.mpg
+lip/GRID/s24/lrab9n.mpg
+lip/GRID/s24/sbbl6a.mpg
+lip/GRID/s24/bbwk1n.mpg
+lip/GRID/s24/brwr1n.mpg
+lip/GRID/s24/bgbszs.mpg
+lip/GRID/s24/bgwf5n.mpg
+lip/GRID/s24/swis4a.mpg
+lip/GRID/s24/lgwy2s.mpg
+lip/GRID/s24/pbim1n.mpg
+lip/GRID/s24/lbwv4s.mpg
+lip/GRID/s24/srbs6a.mpg
+lip/GRID/s24/srir7p.mpg
+lip/GRID/s24/pbbt4s.mpg
+lip/GRID/s24/bwwsza.mpg
+lip/GRID/s24/prwo2a.mpg
+lip/GRID/s24/lgip6s.mpg
+lip/GRID/s24/lbiu3p.mpg
+lip/GRID/s24/lwbj6a.mpg
+lip/GRID/s24/sbbz4a.mpg
+lip/GRID/s24/prag7n.mpg
+lip/GRID/s24/bwae1n.mpg
+lip/GRID/s24/brad8a.mpg
+lip/GRID/s24/lgixzs.mpg
+lip/GRID/s24/lbibzs.mpg
+lip/GRID/s24/sriz1p.mpg
+lip/GRID/s24/bwid9p.mpg
+lip/GRID/s24/lrio6a.mpg
+lip/GRID/s24/lbwc3p.mpg
+lip/GRID/s24/bgir2s.mpg
+lip/GRID/s24/sbar5p.mpg
+lip/GRID/s24/srwm5p.mpg
+lip/GRID/s24/lrbc6a.mpg
+lip/GRID/s24/lwii5n.mpg
+lip/GRID/s24/pwah4s.mpg
+lip/GRID/s24/bgik7n.mpg
+lip/GRID/s24/bgwm1p.mpg
+lip/GRID/s24/bbbj9p.mpg
+lip/GRID/s24/lrwp5n.mpg
+lip/GRID/s24/lbib2a.mpg
+lip/GRID/s24/pbas9n.mpg
+lip/GRID/s24/pwwv1p.mpg
+lip/GRID/s24/pgin9n.mpg
+lip/GRID/s24/pwwi4a.mpg
+lip/GRID/s24/prbh4a.mpg
+lip/GRID/s24/bbip5p.mpg
+lip/GRID/s24/brbezs.mpg
+lip/GRID/s24/prat6s.mpg
+lip/GRID/s24/pbbg8a.mpg
+lip/GRID/s24/bbbd4s.mpg
+lip/GRID/s24/prwh6s.mpg
+lip/GRID/s24/sgam8s.mpg
+lip/GRID/s24/bwiq7p.mpg
+lip/GRID/s24/lwipzs.mpg
+lip/GRID/s24/lrib5n.mpg
+lip/GRID/s24/lgad3p.mpg
+lip/GRID/s24/bgae9p.mpg
+lip/GRID/s24/lrwx1p.mpg
+lip/GRID/s24/lgwq7n.mpg
+lip/GRID/s24/bbax4a.mpg
+lip/GRID/s24/pbis7p.mpg
+lip/GRID/s24/lrbi7n.mpg
+lip/GRID/s24/bwbr6a.mpg
+lip/GRID/s24/sbbz2s.mpg
+lip/GRID/s24/sbae6s.mpg
+lip/GRID/s24/srbz8s.mpg
+lip/GRID/s24/lwav8s.mpg
+lip/GRID/s24/sbie3p.mpg
+lip/GRID/s24/bway6a.mpg
+lip/GRID/s24/prwh7p.mpg
+lip/GRID/s24/lgwq9p.mpg
+lip/GRID/s24/pbim4a.mpg
+lip/GRID/s24/lwiv3n.mpg
+lip/GRID/s24/lwbx2s.mpg
+lip/GRID/s24/lrwj4a.mpg
+lip/GRID/s24/bgie4s.mpg
+lip/GRID/s24/lrivza.mpg
+lip/GRID/s24/bwbe7p.mpg
+lip/GRID/s24/swwn1p.mpg
+lip/GRID/s24/pbbnzs.mpg
+lip/GRID/s24/sgim6a.mpg
+lip/GRID/s24/pwig9n.mpg
+lip/GRID/s24/sbak9n.mpg
+lip/GRID/s24/swwa2s.mpg
+lip/GRID/s24/pwwo6s.mpg
+lip/GRID/s24/lbin8s.mpg
+lip/GRID/s24/srbs3n.mpg
+lip/GRID/s24/lrwc9p.mpg
+lip/GRID/s24/sbik8a.mpg
+lip/GRID/s24/bbaj5p.mpg
+lip/GRID/s24/pbwt7n.mpg
+lip/GRID/s24/bgie6a.mpg
+lip/GRID/s24/lbwi5n.mpg
+lip/GRID/s24/lgaj6s.mpg
+lip/GRID/s24/sral7p.mpg
+lip/GRID/s24/lrwdza.mpg
+lip/GRID/s24/sbae8a.mpg
+lip/GRID/s24/swbm7p.mpg
+lip/GRID/s24/brad6s.mpg
+lip/GRID/s24/bgiy8a.mpg
+lip/GRID/s24/swis2s.mpg
+lip/GRID/s24/pgau8s.mpg
+lip/GRID/s24/pgbc2a.mpg
+lip/GRID/s24/lwbx1n.mpg
+lip/GRID/s24/lrwp8a.mpg
+lip/GRID/s24/pgbo8s.mpg
+lip/GRID/s24/lbau8a.mpg
+lip/GRID/s24/pgib2s.mpg
+lip/GRID/s24/pria2a.mpg
+lip/GRID/s24/lrbi9p.mpg
+lip/GRID/s24/pbwg9n.mpg
+lip/GRID/s24/sbbl4s.mpg
+lip/GRID/s24/bwbl1p.mpg
+lip/GRID/s24/lwip1p.mpg
+lip/GRID/s24/lrwp6s.mpg
+lip/GRID/s24/srifza.mpg
+lip/GRID/s24/sgwn7p.mpg
+lip/GRID/s24/lwwd3n.mpg
+lip/GRID/s24/brak2a.mpg
+lip/GRID/s24/priazs.mpg
+lip/GRID/s24/prwh5n.mpg
+lip/GRID/s24/swam2s.mpg
+lip/GRID/s24/brwk9p.mpg
+lip/GRID/s24/bgiy5n.mpg
+lip/GRID/s24/bbad2a.mpg
+lip/GRID/s24/srir8a.mpg
+lip/GRID/s24/lgij3p.mpg
+lip/GRID/s24/bbax2s.mpg
+lip/GRID/s24/bgbl5n.mpg
+lip/GRID/s24/pbba2s.mpg
+lip/GRID/s24/bbic7p.mpg
+lip/GRID/s24/lbbu9n.mpg
+lip/GRID/s24/pgih8a.mpg
+lip/GRID/s24/lbin7n.mpg
+lip/GRID/s24/swil8s.mpg
+lip/GRID/s24/pwwcza.mpg
+lip/GRID/s24/sbik6s.mpg
+lip/GRID/s24/pwaa9n.mpg
+lip/GRID/s24/brax7n.mpg
+lip/GRID/s24/sgwt9n.mpg
+lip/GRID/s24/sgag3n.mpg
+lip/GRID/s24/lgwq8s.mpg
+lip/GRID/s24/bwwl6a.mpg
+lip/GRID/s24/sbbl3n.mpg
+lip/GRID/s24/praa4s.mpg
+lip/GRID/s24/srbf6s.mpg
+lip/GRID/s24/prim7n.mpg
+lip/GRID/s24/brix6a.mpg
+lip/GRID/s24/sganza.mpg
+lip/GRID/s24/swiz5n.mpg
+lip/GRID/s24/bgwz8s.mpg
+lip/GRID/s24/lbwv6a.mpg
+lip/GRID/s24/prit3p.mpg
+lip/GRID/s24/srizzs.mpg
+lip/GRID/s24/sgwh3p.mpg
+lip/GRID/s24/pwau3p.mpg
+lip/GRID/s24/srwgzs.mpg
+lip/GRID/s24/prinza.mpg
+lip/GRID/s24/sraz6a.mpg
+lip/GRID/s24/bway5p.mpg
+lip/GRID/s24/lgwezs.mpg
+lip/GRID/s24/sril2s.mpg
+lip/GRID/s24/lgix2a.mpg
+lip/GRID/s24/pbwa7p.mpg
+lip/GRID/s24/pbwa8a.mpg
+lip/GRID/s24/pbat1p.mpg
+lip/GRID/s24/sbiy6a.mpg
+lip/GRID/s24/lgbd8a.mpg
+lip/GRID/s24/pgih5n.mpg
+lip/GRID/s24/lriu7n.mpg
+lip/GRID/s24/pwwo5n.mpg
+lip/GRID/s24/brbq7n.mpg
+lip/GRID/s24/prbn6s.mpg
+lip/GRID/s24/bgbf4a.mpg
+lip/GRID/s24/srbl9n.mpg
+lip/GRID/s24/sraz4s.mpg
+lip/GRID/s24/lbwi6s.mpg
+lip/GRID/s24/bwak5n.mpg
+lip/GRID/s24/pria1p.mpg
+lip/GRID/s24/swwg7p.mpg
+lip/GRID/s24/pgiu5p.mpg
+lip/GRID/s24/lwaj2a.mpg
+lip/GRID/s24/sgwu2a.mpg
+lip/GRID/s24/sgwa8s.mpg
+lip/GRID/s24/prwh8a.mpg
+lip/GRID/s24/pbis6s.mpg
+lip/GRID/s24/lgbj9n.mpg
+lip/GRID/s24/swif4s.mpg
+lip/GRID/s24/lbbo8a.mpg
+lip/GRID/s24/bbbd6a.mpg
+lip/GRID/s16/srif8a.mpg
+lip/GRID/s16/lgbe4s.mpg
+lip/GRID/s16/swag8a.mpg
+lip/GRID/s16/prwv3p.mpg
+lip/GRID/s16/swag7p.mpg
+lip/GRID/s16/lgay4a.mpg
+lip/GRID/s16/lwbeza.mpg
+lip/GRID/s16/lgwl2s.mpg
+lip/GRID/s16/sgwo6a.mpg
+lip/GRID/s16/bbad8s.mpg
+lip/GRID/s16/bbij9p.mpg
+lip/GRID/s16/lbao9n.mpg
+lip/GRID/s16/lwby2a.mpg
+lip/GRID/s16/lgak4s.mpg
+lip/GRID/s16/lbwd1p.mpg
+lip/GRID/s16/lgaq7n.mpg
+lip/GRID/s16/sgbo1p.mpg
+lip/GRID/s16/bgaz8s.mpg
+lip/GRID/s16/srbm8s.mpg
+lip/GRID/s16/bwiy7n.mpg
+lip/GRID/s16/pgwd2s.mpg
+lip/GRID/s16/lrav9n.mpg
+lip/GRID/s16/bgwt3p.mpg
+lip/GRID/s16/bwbz7p.mpg
+lip/GRID/s16/sras9p.mpg
+lip/GRID/s16/srwt5n.mpg
+lip/GRID/s16/lwwk5n.mpg
+lip/GRID/s16/bray6s.mpg
+lip/GRID/s16/bwbf3n.mpg
+lip/GRID/s16/lrwj9n.mpg
+lip/GRID/s16/srwn2s.mpg
+lip/GRID/s16/bgbg1p.mpg
+lip/GRID/s16/lgwr7p.mpg
+lip/GRID/s16/bwwm3p.mpg
+lip/GRID/s16/pria7n.mpg
+lip/GRID/s16/bgbs9p.mpg
+lip/GRID/s16/sbil5p.mpg
+lip/GRID/s16/bgam1p.mpg
+lip/GRID/s16/prih1n.mpg
+lip/GRID/s16/lbbj2a.mpg
+lip/GRID/s16/bbbk6s.mpg
+lip/GRID/s16/swaa4a.mpg
+lip/GRID/s16/prbb7p.mpg
+lip/GRID/s16/lrwq5p.mpg
+lip/GRID/s16/bbikza.mpg
+lip/GRID/s16/pbbu1n.mpg
+lip/GRID/s16/sbir8s.mpg
+lip/GRID/s16/brwz5p.mpg
+lip/GRID/s16/bgbs7n.mpg
+lip/GRID/s16/bwaz1n.mpg
+lip/GRID/s16/sgin2s.mpg
+lip/GRID/s16/swwb1p.mpg
+lip/GRID/s16/pgio9p.mpg
+lip/GRID/s16/pbbb1p.mpg
+lip/GRID/s16/lrac7n.mpg
+lip/GRID/s16/lgwl3p.mpg
+lip/GRID/s16/pwbv3n.mpg
+lip/GRID/s16/lrwx9p.mpg
+lip/GRID/s16/brwz6a.mpg
+lip/GRID/s16/swwh3n.mpg
+lip/GRID/s16/bwaf2a.mpg
+lip/GRID/s16/pbbh5p.mpg
+lip/GRID/s16/pwwv8s.mpg
+lip/GRID/s16/lgix9p.mpg
+lip/GRID/s16/bwie8a.mpg
+lip/GRID/s16/lraj2s.mpg
+lip/GRID/s16/bgiszs.mpg
+lip/GRID/s16/sgwh9n.mpg
+lip/GRID/s16/bbwy9p.mpg
+lip/GRID/s16/lgiq5p.mpg
+lip/GRID/s16/prbvza.mpg
+lip/GRID/s16/lrwx8s.mpg
+lip/GRID/s16/bgwm7n.mpg
+lip/GRID/s16/lbai7p.mpg
+lip/GRID/s16/lgaq9p.mpg
+lip/GRID/s16/swwh6a.mpg
+lip/GRID/s16/lbwd2a.mpg
+lip/GRID/s16/lraj3p.mpg
+lip/GRID/s16/lbbxza.mpg
+lip/GRID/s16/bbbrzs.mpg
+lip/GRID/s16/lrbq1p.mpg
+lip/GRID/s16/lgak6a.mpg
+lip/GRID/s16/bbid3n.mpg
+lip/GRID/s16/lbai6s.mpg
+lip/GRID/s16/pwwj2a.mpg
+lip/GRID/s16/sgit6s.mpg
+lip/GRID/s16/lwwe1n.mpg
+lip/GRID/s16/bgaf7p.mpg
+lip/GRID/s16/prao2a.mpg
+lip/GRID/s16/sris4s.mpg
+lip/GRID/s16/lgid6s.mpg
+lip/GRID/s16/pwwi9n.mpg
+lip/GRID/s16/lgbe3n.mpg
+lip/GRID/s16/swwu3p.mpg
+lip/GRID/s16/lrax1p.mpg
+lip/GRID/s16/srbm9p.mpg
+lip/GRID/s16/pwbi5n.mpg
+lip/GRID/s16/pbwu8a.mpg
+lip/GRID/s16/pwio1n.mpg
+lip/GRID/s16/lric3n.mpg
+lip/GRID/s16/pgbp7p.mpg
+lip/GRID/s16/sbwm7p.mpg
+lip/GRID/s16/pbwu5n.mpg
+lip/GRID/s16/prbo3n.mpg
+lip/GRID/s16/sgabza.mpg
+lip/GRID/s16/lwwq9n.mpg
+lip/GRID/s16/sgbu5p.mpg
+lip/GRID/s16/bbiq3p.mpg
+lip/GRID/s16/swat5p.mpg
+lip/GRID/s16/lwbyzs.mpg
+lip/GRID/s16/bbwr4s.mpg
+lip/GRID/s16/lwij3n.mpg
+lip/GRID/s16/bbiq1n.mpg
+lip/GRID/s16/lbio8a.mpg
+lip/GRID/s16/sgbh7p.mpg
+lip/GRID/s16/pbbh6a.mpg
+lip/GRID/s16/brbl4a.mpg
+lip/GRID/s16/lbbc8a.mpg
+lip/GRID/s16/bwwf7n.mpg
+lip/GRID/s16/bgas3n.mpg
+lip/GRID/s16/pgbj3p.mpg
+lip/GRID/s16/pbbb2a.mpg
+lip/GRID/s16/sgit8a.mpg
+lip/GRID/s16/brar1n.mpg
+lip/GRID/s16/sris5p.mpg
+lip/GRID/s16/bgwt1n.mpg
+lip/GRID/s16/sgan7p.mpg
+lip/GRID/s16/srbg3n.mpg
+lip/GRID/s16/lgbe6a.mpg
+lip/GRID/s16/lwwk7p.mpg
+lip/GRID/s16/lgbk8s.mpg
+lip/GRID/s16/pwai3p.mpg
+lip/GRID/s16/pbwh8s.mpg
+lip/GRID/s16/lgwe7n.mpg
+lip/GRID/s16/sgwu9p.mpg
+lip/GRID/s16/bbiq4a.mpg
+lip/GRID/s16/srwg8s.mpg
+lip/GRID/s16/prbo4s.mpg
+lip/GRID/s16/lbwc9n.mpg
+lip/GRID/s16/pgii5p.mpg
+lip/GRID/s16/sbir7n.mpg
+lip/GRID/s16/pbwh7n.mpg
+lip/GRID/s16/briy4a.mpg
+lip/GRID/s16/sbas3p.mpg
+lip/GRID/s16/pwao6s.mpg
+lip/GRID/s16/swag5n.mpg
+lip/GRID/s16/lwid1p.mpg
+lip/GRID/s16/pgii3n.mpg
+lip/GRID/s16/pwwc8a.mpg
+lip/GRID/s16/lgbk9p.mpg
+lip/GRID/s16/brae5p.mpg
+lip/GRID/s16/srbt3p.mpg
+lip/GRID/s16/bgbf9n.mpg
+lip/GRID/s16/bgbg2a.mpg
+lip/GRID/s16/bbaq6s.mpg
+lip/GRID/s16/pwai2s.mpg
+lip/GRID/s16/bgwa1p.mpg
+lip/GRID/s16/sgihza.mpg
+lip/GRID/s16/srimzs.mpg
+lip/GRID/s16/bwil1p.mpg
+lip/GRID/s16/pwio3p.mpg
+lip/GRID/s16/srwn4a.mpg
+lip/GRID/s16/lgiq3n.mpg
+lip/GRID/s16/bwwf8s.mpg
+lip/GRID/s16/bwaz4a.mpg
+lip/GRID/s16/sriz8s.mpg
+lip/GRID/s16/sgwb8a.mpg
+lip/GRID/s16/swwn7n.mpg
+lip/GRID/s16/lrwd6s.mpg
+lip/GRID/s16/lbio7p.mpg
+lip/GRID/s16/pgii6a.mpg
+lip/GRID/s16/lwwr1p.mpg
+lip/GRID/s16/bbad7n.mpg
+lip/GRID/s16/sbifzs.mpg
+lip/GRID/s16/lbbv7n.mpg
+lip/GRID/s16/lwwk8a.mpg
+lip/GRID/s16/pgiv2s.mpg
+lip/GRID/s16/lrap8a.mpg
+lip/GRID/s16/pbwb3n.mpg
+lip/GRID/s16/lrap7p.mpg
+lip/GRID/s16/priu2a.mpg
+lip/GRID/s16/bwal6a.mpg
+lip/GRID/s16/prin8a.mpg
+lip/GRID/s16/lgiyza.mpg
+lip/GRID/s16/bbbq9n.mpg
+lip/GRID/s16/pgwj6s.mpg
+lip/GRID/s16/srbg4s.mpg
+lip/GRID/s16/lric6a.mpg
+lip/GRID/s16/srim1p.mpg
+lip/GRID/s16/sriz9p.mpg
+lip/GRID/s16/lgbr2s.mpg
+lip/GRID/s16/brbe9p.mpg
+lip/GRID/s16/prbu9p.mpg
+lip/GRID/s16/bbbr2a.mpg
+lip/GRID/s16/bbby3n.mpg
+lip/GRID/s16/brar3p.mpg
+lip/GRID/s16/lbicza.mpg
+lip/GRID/s16/swbn5p.mpg
+lip/GRID/s16/sratza.mpg
+lip/GRID/s16/srbnza.mpg
+lip/GRID/s16/lbii1n.mpg
+lip/GRID/s16/priu1p.mpg
+lip/GRID/s16/lgwr6s.mpg
+lip/GRID/s16/sgin3p.mpg
+lip/GRID/s16/lbbv9p.mpg
+lip/GRID/s16/lwax8a.mpg
+lip/GRID/s16/bgwg3n.mpg
+lip/GRID/s16/praozs.mpg
+lip/GRID/s16/prwv4a.mpg
+lip/GRID/s16/brwl7p.mpg
+lip/GRID/s16/briezs.mpg
+lip/GRID/s16/pwbi6s.mpg
+lip/GRID/s16/bbbk8a.mpg
+lip/GRID/s16/swwh5p.mpg
+lip/GRID/s16/lwbd7n.mpg
+lip/GRID/s16/srbt2s.mpg
+lip/GRID/s16/lbib9p.mpg
+lip/GRID/s16/bbij8s.mpg
+lip/GRID/s16/sris6a.mpg
+lip/GRID/s16/briq7n.mpg
+lip/GRID/s16/pgwj8a.mpg
+lip/GRID/s16/sgwo4s.mpg
+lip/GRID/s16/bwal3n.mpg
+lip/GRID/s16/pran9n.mpg
+lip/GRID/s16/brar2s.mpg
+lip/GRID/s16/bbwy7n.mpg
+lip/GRID/s16/srbg5p.mpg
+lip/GRID/s16/brie1p.mpg
+lip/GRID/s16/lrwq3n.mpg
+lip/GRID/s16/pgai8s.mpg
+lip/GRID/s16/lwix3p.mpg
+lip/GRID/s16/lbwj6a.mpg
+lip/GRID/s16/lbwx2s.mpg
+lip/GRID/s16/prao1p.mpg
+lip/GRID/s16/sgauzs.mpg
+lip/GRID/s16/pbat7n.mpg
+lip/GRID/s16/swiaza.mpg
+lip/GRID/s16/bwbmza.mpg
+lip/GRID/s16/bbak1n.mpg
+lip/GRID/s16/prbo6a.mpg
+lip/GRID/s16/lbivzs.mpg
+lip/GRID/s16/prbu7n.mpg
+lip/GRID/s16/bgiz3n.mpg
+lip/GRID/s16/pgbj2s.mpg
+lip/GRID/s16/lrwyza.mpg
+lip/GRID/s16/bwws7p.mpg
+lip/GRID/s16/bgbm4s.mpg
+lip/GRID/s16/bwbz5n.mpg
+lip/GRID/s16/swwa9n.mpg
+lip/GRID/s16/sbwtzs.mpg
+lip/GRID/s16/pbwo3p.mpg
+lip/GRID/s16/bbwe8a.mpg
+lip/GRID/s16/lbwp9p.mpg
+lip/GRID/s16/lbwj3n.mpg
+lip/GRID/s16/pwih9p.mpg
+lip/GRID/s2/sria8a.mpg
+lip/GRID/s2/sgac1n.mpg
+lip/GRID/s2/swbv4a.mpg
+lip/GRID/s2/bbaz5p.mpg
+lip/GRID/s2/bbbs6a.mpg
+lip/GRID/s2/lgil5p.mpg
+lip/GRID/s2/lwaz1p.mpg
+lip/GRID/s2/lrwe9n.mpg
+lip/GRID/s2/pric1n.mpg
+lip/GRID/s2/lbaj9n.mpg
+lip/GRID/s2/swib2s.mpg
+lip/GRID/s2/lbid3p.mpg
+lip/GRID/s2/bris4a.mpg
+lip/GRID/s2/prav7n.mpg
+lip/GRID/s2/bgbu2s.mpg
+lip/GRID/s2/srwo7p.mpg
+lip/GRID/s2/sbba8s.mpg
+lip/GRID/s2/bwitza.mpg
+lip/GRID/s2/sbbn5n.mpg
+lip/GRID/s2/sbaa6a.mpg
+lip/GRID/s2/pwwy4a.mpg
+lip/GRID/s2/bgia3p.mpg
+lip/GRID/s2/lwbl6s.mpg
+lip/GRID/s2/bgwb4s.mpg
+lip/GRID/s2/bgwu5n.mpg
+lip/GRID/s2/bgit4s.mpg
+lip/GRID/s2/lbix3n.mpg
+lip/GRID/s2/sbwozs.mpg
+lip/GRID/s2/bwba5p.mpg
+lip/GRID/s2/lrbr3n.mpg
+lip/GRID/s2/lrwz1n.mpg
+lip/GRID/s2/srab1p.mpg
+lip/GRID/s2/srihzs.mpg
+lip/GRID/s2/bwwu1p.mpg
+lip/GRID/s2/lbak2a.mpg
+lip/GRID/s2/pgbe3p.mpg
+lip/GRID/s2/lrae2s.mpg
+lip/GRID/s2/sgbi9n.mpg
+lip/GRID/s2/lrwl4s.mpg
+lip/GRID/s2/swbv2s.mpg
+lip/GRID/s2/bwam9p.mpg
+lip/GRID/s2/pwiv9n.mpg
+lip/GRID/s2/srin4s.mpg
+lip/GRID/s2/pbac1p.mpg
+lip/GRID/s2/prwkza.mpg
+lip/GRID/s2/prii7p.mpg
+lip/GRID/s2/lwws5p.mpg
+lip/GRID/s2/swwi8s.mpg
+lip/GRID/s2/swio1p.mpg
+lip/GRID/s2/pwaj5n.mpg
+lip/GRID/s2/sgwj5p.mpg
+lip/GRID/s2/pwwy2s.mpg
+lip/GRID/s2/pbii2a.mpg
+lip/GRID/s2/pgaeza.mpg
+lip/GRID/s2/srwb9p.mpg
+lip/GRID/s2/sgbj1p.mpg
+lip/GRID/s2/bwwh2s.mpg
+lip/GRID/s2/lrby7n.mpg
+lip/GRID/s2/braz9n.mpg
+lip/GRID/s2/lbwr2s.mpg
+lip/GRID/s2/brwt4s.mpg
+lip/GRID/s2/pbwx2a.mpg
+lip/GRID/s2/pric3p.mpg
+lip/GRID/s2/lbaq3n.mpg
+lip/GRID/s2/lgil6a.mpg
+lip/GRID/s2/lgbz9n.mpg
+lip/GRID/s2/sgib9p.mpg
+lip/GRID/s2/bgin2a.mpg
+lip/GRID/s2/pwad4a.mpg
+lip/GRID/s2/pgbk6s.mpg
+lip/GRID/s2/bgit6a.mpg
+lip/GRID/s2/pbiizs.mpg
+lip/GRID/s2/lrae1n.mpg
+lip/GRID/s2/bwim6a.mpg
+lip/GRID/s2/lrik2s.mpg
+lip/GRID/s2/swao5p.mpg
+lip/GRID/s2/pgwl1p.mpg
+lip/GRID/s2/srwi4a.mpg
+lip/GRID/s2/brwa4a.mpg
+lip/GRID/s2/pbbp1n.mpg
+lip/GRID/s2/sria5n.mpg
+lip/GRID/s2/bgbb2a.mpg
+lip/GRID/s2/bbaz6a.mpg
+lip/GRID/s2/lrbe7p.mpg
+lip/GRID/s2/bbal6s.mpg
+lip/GRID/s2/swbi3n.mpg
+lip/GRID/s2/sraoza.mpg
+lip/GRID/s2/bbaz4s.mpg
+lip/GRID/s2/pbbp3p.mpg
+lip/GRID/s2/sria7p.mpg
+lip/GRID/s2/pwbq6a.mpg
+lip/GRID/s2/sbig6a.mpg
+lip/GRID/s2/pgayzs.mpg
+lip/GRID/s2/lrak5n.mpg
+lip/GRID/s2/srau2s.mpg
+lip/GRID/s2/sgap1p.mpg
+lip/GRID/s2/pbbc6a.mpg
+lip/GRID/s2/bgia4a.mpg
+lip/GRID/s2/pgbe4a.mpg
+lip/GRID/s2/bgag9n.mpg
+lip/GRID/s2/pbwc9p.mpg
+lip/GRID/s2/bgbh3n.mpg
+lip/GRID/s2/lwal1n.mpg
+lip/GRID/s2/sbbh2s.mpg
+lip/GRID/s2/lbij8a.mpg
+lip/GRID/s2/prbd2a.mpg
+lip/GRID/s2/srwb8s.mpg
+lip/GRID/s2/lrbr4s.mpg
+lip/GRID/s2/brbaza.mpg
+lip/GRID/s2/lbij6s.mpg
+lip/GRID/s2/pbwp6s.mpg
+lip/GRID/s2/pbai6a.mpg
+lip/GRID/s2/prwx7p.mpg
+lip/GRID/s2/sgbv9p.mpg
+lip/GRID/s2/bbiz2a.mpg
+lip/GRID/s2/lrik3p.mpg
+lip/GRID/s2/bwwh4a.mpg
+lip/GRID/s2/brwg5n.mpg
+lip/GRID/s2/pwip6s.mpg
+lip/GRID/s2/srin6a.mpg
+lip/GRID/s2/swai2a.mpg
+lip/GRID/s2/sban3p.mpg
+lip/GRID/s2/sbig3n.mpg
+lip/GRID/s2/lbax9p.mpg
+lip/GRID/s2/prap4s.mpg
+lip/GRID/s2/swaizs.mpg
+lip/GRID/s2/lwbz4s.mpg
+lip/GRID/s2/lgbs5n.mpg
+lip/GRID/s2/brbm6s.mpg
+lip/GRID/s2/srih1p.mpg
+lip/GRID/s2/prii5n.mpg
+lip/GRID/s2/lgir7n.mpg
+lip/GRID/s2/lwazzs.mpg
+lip/GRID/s2/pwbyza.mpg
+lip/GRID/s2/bbws8s.mpg
+lip/GRID/s2/bras5n.mpg
+lip/GRID/s2/srbo2s.mpg
+lip/GRID/s2/bwag6a.mpg
+lip/GRID/s2/swbc2a.mpg
+lip/GRID/s2/pgbe2s.mpg
+lip/GRID/s2/bbwg2a.mpg
+lip/GRID/s2/lbid4a.mpg
+lip/GRID/s2/lbby2s.mpg
+lip/GRID/s2/briz8a.mpg
+lip/GRID/s2/bwis9p.mpg
+lip/GRID/s2/bgahzs.mpg
+lip/GRID/s2/prwq2s.mpg
+lip/GRID/s2/sgbc8a.mpg
+lip/GRID/s2/lgaz5n.mpg
+lip/GRID/s2/prii6s.mpg
+lip/GRID/s2/bgah1p.mpg
+lip/GRID/s2/pwwk6a.mpg
+lip/GRID/s2/lbij5n.mpg
+lip/GRID/s2/pgaq5n.mpg
+lip/GRID/s2/pgby5p.mpg
+lip/GRID/s2/bgia1n.mpg
+lip/GRID/s2/bwag3n.mpg
+lip/GRID/s2/swao4s.mpg
+lip/GRID/s2/pgiq4a.mpg
+lip/GRID/s2/brwa2s.mpg
+lip/GRID/s2/pgwe8a.mpg
+lip/GRID/s2/bbal5n.mpg
+lip/GRID/s2/lrik1n.mpg
+lip/GRID/s2/lgws9n.mpg
+lip/GRID/s2/pwidza.mpg
+lip/GRID/s2/lwal3p.mpg
+lip/GRID/s2/brbm7p.mpg
+lip/GRID/s2/pwaq1p.mpg
+lip/GRID/s2/brbg2s.mpg
+lip/GRID/s2/sran8s.mpg
+lip/GRID/s2/lgbf9p.mpg
+lip/GRID/s2/lwir3p.mpg
+lip/GRID/s2/pbwx1p.mpg
+lip/GRID/s2/pbbi8s.mpg
+lip/GRID/s2/bwba3n.mpg
+lip/GRID/s2/swau8s.mpg
+lip/GRID/s2/pbaczs.mpg
+lip/GRID/s2/pbao8s.mpg
+lip/GRID/s2/lrwf2a.mpg
+lip/GRID/s2/sgai6s.mpg
+lip/GRID/s2/pgbr1p.mpg
+lip/GRID/s2/lbby1n.mpg
+lip/GRID/s2/swwv8a.mpg
+lip/GRID/s2/praxza.mpg
+lip/GRID/s2/sgai5n.mpg
+lip/GRID/s2/srig9n.mpg
+lip/GRID/s2/lrae4a.mpg
+lip/GRID/s2/pwwk4s.mpg
+lip/GRID/s2/lwbz6a.mpg
+lip/GRID/s2/pgak2s.mpg
+lip/GRID/s2/bbizzs.mpg
+lip/GRID/s2/pwij1n.mpg
+lip/GRID/s2/pbio4s.mpg
+lip/GRID/s2/swih5n.mpg
+lip/GRID/s2/bgaa5n.mpg
+lip/GRID/s2/bgat8s.mpg
+lip/GRID/s2/pgikza.mpg
+lip/GRID/s2/bwwn7p.mpg
+lip/GRID/s2/sgicza.mpg
+lip/GRID/s2/pwix1p.mpg
+lip/GRID/s2/srbb6a.mpg
+lip/GRID/s2/lwwl9n.mpg
+lip/GRID/s2/swib3p.mpg
+lip/GRID/s2/sgiv1p.mpg
+lip/GRID/s2/srbb3n.mpg
+lip/GRID/s2/lgwm6s.mpg
+lip/GRID/s2/bwbg7n.mpg
+lip/GRID/s2/pgwr6a.mpg
+lip/GRID/s2/bbbz7n.mpg
+lip/GRID/s2/sgac4a.mpg
+lip/GRID/s2/sgwqza.mpg
+lip/GRID/s2/prbd1p.mpg
+lip/GRID/s2/lgwm7p.mpg
+lip/GRID/s2/pbio6a.mpg
+lip/GRID/s2/lwbszs.mpg
+lip/GRID/s2/lwik9p.mpg
+lip/GRID/s2/sbwb3p.mpg
+lip/GRID/s2/lrwl3n.mpg
+lip/GRID/s2/sbat5n.mpg
+lip/GRID/s2/bwbn4a.mpg
+lip/GRID/s2/lriyzs.mpg
+lip/GRID/s2/pgak3p.mpg
+lip/GRID/s2/bbbf8a.mpg
+lip/GRID/s2/bbaz3n.mpg
+lip/GRID/s2/srit8s.mpg
+lip/GRID/s2/pwbq4s.mpg
+lip/GRID/s2/bril8s.mpg
+lip/GRID/s2/lbwe4s.mpg
+lip/GRID/s2/sgwx3p.mpg
+lip/GRID/s2/swwp1n.mpg
+lip/GRID/s2/bgan4s.mpg
+lip/GRID/s2/lwar8a.mpg
+lip/GRID/s2/prac8a.mpg
+lip/GRID/s2/sgbj2a.mpg
+lip/GRID/s2/pgwy7n.mpg
+lip/GRID/s2/swbi4s.mpg
+lip/GRID/s2/pgwy9p.mpg
+lip/GRID/s2/swwp4a.mpg
+lip/GRID/s2/pgwe6s.mpg
+lip/GRID/s2/bgat9p.mpg
+lip/GRID/s2/lwae8s.mpg
+lip/GRID/s2/lbaq4s.mpg
+lip/GRID/s2/braf8s.mpg
+lip/GRID/s2/bragza.mpg
+lip/GRID/s2/lrblzs.mpg
+lip/GRID/s2/sbia1p.mpg
+lip/GRID/s2/bbar9n.mpg
+lip/GRID/s2/prwd3n.mpg
+lip/GRID/s2/sraa9n.mpg
+lip/GRID/s2/pbbv5n.mpg
+lip/GRID/s2/lgwt2a.mpg
+lip/GRID/s2/lrwl6a.mpg
+lip/GRID/s2/lgiz4a.mpg
+lip/GRID/s2/brbt1p.mpg
+lip/GRID/s2/lwbf4a.mpg
+lip/GRID/s7/swbh9s.mpg
+lip/GRID/s7/lwwl7a.mpg
+lip/GRID/s7/lgwz8n.mpg
+lip/GRID/s7/lrbe1s.mpg
+lip/GRID/s7/lwbr5s.mpg
+lip/GRID/s7/pwbx3s.mpg
+lip/GRID/s7/pgad4p.mpg
+lip/GRID/s7/lrwy8p.mpg
+lip/GRID/s7/bwbm6n.mpg
+lip/GRID/s7/bwbt1s.mpg
+lip/GRID/s7/sgbc3a.mpg
+lip/GRID/s7/sgwv9a.mpg
+lip/GRID/s7/pwwd5s.mpg
+lip/GRID/s7/srwu6p.mpg
+lip/GRID/s7/lrix4n.mpg
+lip/GRID/s7/bbbr9s.mpg
+lip/GRID/s7/bwif7a.mpg
+lip/GRID/s7/lwwf1s.mpg
+lip/GRID/s7/lbbq5a.mpg
+lip/GRID/s7/sran2n.mpg
+lip/GRID/s7/sbam9a.mpg
+lip/GRID/s7/pgix3a.mpg
+lip/GRID/s7/bwiz6n.mpg
+lip/GRID/s7/pgij5a.mpg
+lip/GRID/s7/srbn9a.mpg
+lip/GRID/s7/lrix6p.mpg
+lip/GRID/s7/lbwd8n.mpg
+lip/GRID/s7/bbbl4n.mpg
+lip/GRID/s7/sgwp2n.mpg
+lip/GRID/s7/bgaa3a.mpg
+lip/GRID/s7/sgab9a.mpg
+lip/GRID/s7/sgwv8p.mpg
+lip/GRID/s7/sbam6n.mpg
+lip/GRID/s7/lrby2n.mpg
+lip/GRID/s7/prbv8p.mpg
+lip/GRID/s7/lrwr3s.mpg
+lip/GRID/s7/lgiy8p.mpg
+lip/GRID/s7/bgim4n.mpg
+lip/GRID/s7/lrwr5a.mpg
+lip/GRID/s7/lbip6p.mpg
+lip/GRID/s7/bgig2p.mpg
+lip/GRID/s7/lwwz2n.mpg
+lip/GRID/s7/pbaizp.mpg
+lip/GRID/s7/bwis2n.mpg
+lip/GRID/s7/sgih7s.mpg
+lip/GRID/s7/swwi2n.mpg
+lip/GRID/s7/lrij7s.mpg
+lip/GRID/s7/lrbk5s.mpg
+lip/GRID/s7/lwae3s.mpg
+lip/GRID/s7/pbao2n.mpg
+lip/GRID/s7/lrax8n.mpg
+lip/GRID/s7/sgwjzp.mpg
+lip/GRID/s7/lwwz4p.mpg
+lip/GRID/s7/pwwx6n.mpg
+lip/GRID/s7/lwiy2p.mpg
+lip/GRID/s7/swin7a.mpg
+lip/GRID/s7/sgai1s.mpg
+lip/GRID/s7/bbik9a.mpg
+lip/GRID/s7/srbh5a.mpg
+lip/GRID/s7/lway6p.mpg
+lip/GRID/s7/lgbz5s.mpg
+lip/GRID/s7/pbwc2n.mpg
+lip/GRID/s7/bgig3a.mpg
+lip/GRID/s7/prwx1s.mpg
+lip/GRID/s7/pbwv4n.mpg
+lip/GRID/s7/lgwf6n.mpg
+lip/GRID/s7/sgwp5a.mpg
+lip/GRID/s7/sbat1s.mpg
+lip/GRID/s7/bgwb1a.mpg
+lip/GRID/s7/sgiu6p.mpg
+lip/GRID/s7/lgal4p.mpg
+lip/GRID/s7/srat7s.mpg
+lip/GRID/s7/prai6p.mpg
+lip/GRID/s7/lwwl4n.mpg
+lip/GRID/s7/lbbx6n.mpg
+lip/GRID/s7/pgbq5s.mpg
+lip/GRID/s7/lrbezn.mpg
+lip/GRID/s7/bwas6n.mpg
+lip/GRID/s7/prbp4p.mpg
+lip/GRID/s7/lwwl6p.mpg
+lip/GRID/s7/pwwd4n.mpg
+lip/GRID/s7/bwas8p.mpg
+lip/GRID/s7/sgao6p.mpg
+lip/GRID/s7/pbbi4p.mpg
+lip/GRID/s7/pbbo6n.mpg
+lip/GRID/s7/braf3s.mpg
+lip/GRID/s7/lbbd7a.mpg
+lip/GRID/s7/sbag5a.mpg
+lip/GRID/s7/sbbg7s.mpg
+lip/GRID/s7/bbwz8p.mpg
+lip/GRID/s7/bgba5s.mpg
+lip/GRID/s7/pbwc5a.mpg
+lip/GRID/s7/lrwe4n.mpg
+lip/GRID/s7/pbih4n.mpg
+lip/GRID/s7/srwu5s.mpg
+lip/GRID/s7/pbib3a.mpg
+lip/GRID/s7/srit2n.mpg
+lip/GRID/s7/lwiyzn.mpg
+lip/GRID/s7/lwby8n.mpg
+lip/GRID/s7/pgbd9a.mpg
+lip/GRID/s7/lgbf3s.mpg
+lip/GRID/s7/braf4p.mpg
+lip/GRID/s7/bbwz7s.mpg
+lip/GRID/s7/swwv2p.mpg
+lip/GRID/s7/bwim1a.mpg
+lip/GRID/s7/lgbl8p.mpg
+lip/GRID/s7/lriq2p.mpg
+lip/GRID/s7/bgwn9a.mpg
+lip/GRID/s7/sgiu5s.mpg
+lip/GRID/s7/lwwr8n.mpg
+lip/GRID/s7/prwx2p.mpg
+lip/GRID/s7/sbbg8p.mpg
+lip/GRID/s7/bbie3s.mpg
+lip/GRID/s7/sgib3s.mpg
+lip/GRID/s7/lbip4n.mpg
+lip/GRID/s7/pbbb8n.mpg
+lip/GRID/s7/bbbszp.mpg
+lip/GRID/s7/lrbr1a.mpg
+lip/GRID/s7/swbb4n.mpg
+lip/GRID/s7/pbbczp.mpg
+lip/GRID/s7/sbwa7s.mpg
+lip/GRID/s7/srbn7s.mpg
+lip/GRID/s7/pgbd8p.mpg
+lip/GRID/s7/bbar5s.mpg
+lip/GRID/s7/lbip7a.mpg
+lip/GRID/s7/pgad5a.mpg
+lip/GRID/s7/lrbrzp.mpg
+lip/GRID/s7/srahzp.mpg
+lip/GRID/s7/pwbj6p.mpg
+lip/GRID/s7/sbwa6n.mpg
+lip/GRID/s7/pbib1s.mpg
+lip/GRID/s7/pbau7s.mpg
+lip/GRID/s7/pgwy4p.mpg
+lip/GRID/s7/brir6n.mpg
+lip/GRID/s7/bbwm1a.mpg
+lip/GRID/s7/lrby4p.mpg
+lip/GRID/s7/sran5a.mpg
+lip/GRID/s7/bgba4n.mpg
+lip/GRID/s7/bgat4p.mpg
+lip/GRID/s7/sgwc6p.mpg
+lip/GRID/s7/lriqzn.mpg
+lip/GRID/s7/sbat2p.mpg
+lip/GRID/s7/sgwi9s.mpg
+lip/GRID/s7/bwbg5a.mpg
+lip/GRID/s7/bbik7s.mpg
+lip/GRID/s7/bwam4p.mpg
+lip/GRID/s7/sbag3s.mpg
+lip/GRID/s7/pbiu4p.mpg
+lip/GRID/s7/swih1s.mpg
+lip/GRID/s7/srba8n.mpg
+lip/GRID/s7/bwwt5s.mpg
+lip/GRID/s7/pbwc3s.mpg
+lip/GRID/s7/lray1a.mpg
+lip/GRID/s7/lwbe9a.mpg
+lip/GRID/s7/sgaizn.mpg
+lip/GRID/s7/lbbx7s.mpg
+lip/GRID/s7/prwc9s.mpg
+lip/GRID/s7/pgic8n.mpg
+lip/GRID/s7/lbwe1a.mpg
+lip/GRID/s7/pbwv5s.mpg
+lip/GRID/s7/prai5s.mpg
+lip/GRID/s7/sbim2n.mpg
+lip/GRID/s7/bwbm7s.mpg
+lip/GRID/s7/bbwf7a.mpg
+lip/GRID/s7/priizn.mpg
+lip/GRID/s7/prwj3s.mpg
+lip/GRID/s7/sria2p.mpg
+lip/GRID/s7/swbu8p.mpg
+lip/GRID/s7/lgar7s.mpg
+lip/GRID/s7/pgax7a.mpg
+lip/GRID/s7/sgbczn.mpg
+lip/GRID/s7/pgwrzp.mpg
+lip/GRID/s7/pbbi2n.mpg
+lip/GRID/s7/bwag1a.mpg
+lip/GRID/s7/lrwk9s.mpg
+lip/GRID/s7/sbwn7a.mpg
+lip/GRID/s7/lbic6n.mpg
+lip/GRID/s7/sgbpzp.mpg
+lip/GRID/s7/bgwa8n.mpg
+lip/GRID/s7/lbixzp.mpg
+lip/GRID/s7/brizzn.mpg
+lip/GRID/s7/lwak6n.mpg
+lip/GRID/s7/srwh6n.mpg
+lip/GRID/s7/bwwa4p.mpg
+lip/GRID/s7/lwae5a.mpg
+lip/GRID/s7/briz3a.mpg
+lip/GRID/s7/pwiv7a.mpg
+lip/GRID/s7/pbah8n.mpg
+lip/GRID/s7/sraa7a.mpg
+lip/GRID/s7/prwp7s.mpg
+lip/GRID/s7/pgip6n.mpg
+lip/GRID/s7/bgba6p.mpg
+lip/GRID/s7/lbwy1s.mpg
+lip/GRID/s7/sgbc2p.mpg
+lip/GRID/s7/srim9s.mpg
+lip/GRID/s7/bgwh5a.mpg
+lip/GRID/s7/swwi5a.mpg
+lip/GRID/s7/swiuzp.mpg
+lip/GRID/s7/lwiq6n.mpg
+lip/GRID/s7/brwm6p.mpg
+lip/GRID/s7/srag8n.mpg
+lip/GRID/s7/pgwe3a.mpg
+lip/GRID/s7/bbws2n.mpg
+lip/GRID/s7/pbbvzn.mpg
+lip/GRID/s7/srat9a.mpg
+lip/GRID/s7/sgwc7a.mpg
+lip/GRID/s7/pbiozp.mpg
+lip/GRID/s7/sbwh2p.mpg
+lip/GRID/s7/bbay8n.mpg
+lip/GRID/s7/pwwq2n.mpg
+lip/GRID/s7/lbad3a.mpg
+lip/GRID/s7/brbf9a.mpg
+lip/GRID/s7/prio7a.mpg
+lip/GRID/s7/prii2p.mpg
+lip/GRID/s7/sgau8n.mpg
+lip/GRID/s7/pbao3s.mpg
+lip/GRID/s7/lwwf3a.mpg
+lip/GRID/s7/brir7s.mpg
+lip/GRID/s7/pbbv1s.mpg
+lip/GRID/s7/pgid1a.mpg
+lip/GRID/s7/lwwfzn.mpg
+lip/GRID/s7/lgir4p.mpg
+lip/GRID/s7/lbbx8p.mpg
+lip/GRID/s7/sbbg6n.mpg
+lip/GRID/s7/bwil8n.mpg
+lip/GRID/s7/lgwm1s.mpg
+lip/GRID/s7/brbz9s.mpg
+lip/GRID/s7/sbbt7a.mpg
+lip/GRID/s7/bwis5a.mpg
+lip/GRID/s7/lrij6n.mpg
+lip/GRID/s7/sriazn.mpg
+lip/GRID/s7/bgigzn.mpg
+lip/GRID/s7/bbae9a.mpg
+lip/GRID/s7/pbiu3s.mpg
+lip/GRID/s7/bwas7s.mpg
+lip/GRID/s7/bbwf5s.mpg
+lip/GRID/s7/bgbt7s.mpg
+lip/GRID/s7/pwap4n.mpg
+lip/GRID/s7/lrbe2p.mpg
+lip/GRID/s7/brbs6p.mpg
+lip/GRID/s7/pgaj7s.mpg
+lip/GRID/s7/pbih7a.mpg
+lip/GRID/s7/bwwt7a.mpg
+lip/GRID/s7/pbib2p.mpg
+lip/GRID/s7/sbwh3a.mpg
+lip/GRID/s7/sgbo8n.mpg
+lip/GRID/s7/pwbp9s.mpg
+lip/GRID/s7/lgbf2n.mpg
+lip/GRID/s7/briz2p.mpg
+lip/GRID/s7/prao8n.mpg
+lip/GRID/s7/lwwr9s.mpg
+lip/GRID/s7/srwu4n.mpg
+lip/GRID/s7/pwbj4n.mpg
+lip/GRID/s7/lrbk7a.mpg
+lip/GRID/s7/swia9a.mpg
+lip/GRID/s31/bgwr6n.mpg
+lip/GRID/s31/bwwk7s.mpg
+lip/GRID/s31/lgwj9a.mpg
+lip/GRID/s31/pbbf9s.mpg
+lip/GRID/s31/sgiz7a.mpg
+lip/GRID/s31/lgbp9a.mpg
+lip/GRID/s31/swwf9s.mpg
+lip/GRID/s31/brij1a.mpg
+lip/GRID/s31/bbbp7a.mpg
+lip/GRID/s31/sgif4p.mpg
+lip/GRID/s31/pwwb1s.mpg
+lip/GRID/s31/lrwo8n.mpg
+lip/GRID/s31/pbwazp.mpg
+lip/GRID/s31/srirzp.mpg
+lip/GRID/s31/bwwy5s.mpg
+lip/GRID/s31/bbbxzp.mpg
+lip/GRID/s31/brbx6p.mpg
+lip/GRID/s31/sgbs9s.mpg
+lip/GRID/s31/bgwz2p.mpg
+lip/GRID/s31/pwag7s.mpg
+lip/GRID/s31/pgit7s.mpg
+lip/GRID/s31/prwt8p.mpg
+lip/GRID/s31/bwakzp.mpg
+lip/GRID/s31/sgbg3a.mpg
+lip/GRID/s31/lbin3a.mpg
+lip/GRID/s31/bbwdzn.mpg
+lip/GRID/s31/sbwy9s.mpg
+lip/GRID/s31/lbia3s.mpg
+lip/GRID/s31/lbbb2p.mpg
+lip/GRID/s31/lgwx6p.mpg
+lip/GRID/s31/pgig8n.mpg
+lip/GRID/s31/swws7s.mpg
+lip/GRID/s31/pgwb6n.mpg
+lip/GRID/s31/lbia2n.mpg
+lip/GRID/s31/pbam1a.mpg
+lip/GRID/s31/lgwj8p.mpg
+lip/GRID/s31/lrbi2p.mpg
+lip/GRID/s31/sbid7a.mpg
+lip/GRID/s31/pwbn5s.mpg
+lip/GRID/s31/lgbj2n.mpg
+lip/GRID/s31/sbay2p.mpg
+lip/GRID/s31/pgbh6n.mpg
+lip/GRID/s31/bgik1s.mpg
+lip/GRID/s31/prba1s.mpg
+lip/GRID/s31/sbix6n.mpg
+lip/GRID/s31/sgwn1a.mpg
+lip/GRID/s31/pgia4n.mpg
+lip/GRID/s31/lbwo3s.mpg
+lip/GRID/s31/bwbezp.mpg
+lip/GRID/s31/sbwr4n.mpg
+lip/GRID/s31/pbas5a.mpg
+lip/GRID/s31/lwwc8p.mpg
+lip/GRID/s31/sgam1s.mpg
+lip/GRID/s31/sray8p.mpg
+lip/GRID/s31/pbwg4p.mpg
+lip/GRID/s31/lrwp1a.mpg
+lip/GRID/s31/brijzp.mpg
+lip/GRID/s31/lgwqzn.mpg
+lip/GRID/s31/lrah7s.mpg
+lip/GRID/s31/pgab1a.mpg
+lip/GRID/s31/lbbo1a.mpg
+lip/GRID/s31/srar2n.mpg
+lip/GRID/s31/pwbt8n.mpg
+lip/GRID/s31/pbal9s.mpg
+lip/GRID/s31/bbbc9a.mpg
+lip/GRID/s31/bbbj1s.mpg
+lip/GRID/s31/sbiq2n.mpg
+lip/GRID/s31/lgwd4p.mpg
+lip/GRID/s31/srbr7s.mpg
+lip/GRID/s31/lrih5a.mpg
+lip/GRID/s31/pwwn8n.mpg
+lip/GRID/s31/pgwb8p.mpg
+lip/GRID/s31/bric7a.mpg
+lip/GRID/s31/lgai8n.mpg
+lip/GRID/s31/sgas4n.mpg
+lip/GRID/s31/pbwm8p.mpg
+lip/GRID/s31/brii9s.mpg
+lip/GRID/s31/pwwu5a.mpg
+lip/GRID/s31/lwbc5a.mpg
+lip/GRID/s31/bgak6p.mpg
+lip/GRID/s31/sbad8n.mpg
+lip/GRID/s31/bradzp.mpg
+lip/GRID/s31/lgbd1a.mpg
+lip/GRID/s31/prif9a.mpg
+lip/GRID/s31/lbwb7a.mpg
+lip/GRID/s31/lbig9a.mpg
+lip/GRID/s31/lgaj1a.mpg
+lip/GRID/s31/pwwo1a.mpg
+lip/GRID/s31/bwbq9a.mpg
+lip/GRID/s31/pgin2n.mpg
+lip/GRID/s31/bbac3s.mpg
+lip/GRID/s31/sgas6p.mpg
+lip/GRID/s31/braj4p.mpg
+lip/GRID/s31/lwbp1s.mpg
+lip/GRID/s31/lgiv3s.mpg
+lip/GRID/s31/bbbp5s.mpg
+lip/GRID/s31/lgap5a.mpg
+lip/GRID/s31/pbbm3s.mpg
+lip/GRID/s31/lwbi7s.mpg
+lip/GRID/s31/sbaq9a.mpg
+lip/GRID/s31/lgii7a.mpg
+lip/GRID/s31/prbm8n.mpg
+lip/GRID/s31/pbiz5a.mpg
+lip/GRID/s31/bgbr3s.mpg
+lip/GRID/s31/pbbm4p.mpg
+lip/GRID/s31/lriuzn.mpg
+lip/GRID/s31/swaz2n.mpg
+lip/GRID/s31/lwio2n.mpg
+lip/GRID/s31/bwwy7a.mpg
+lip/GRID/s31/pbbs9a.mpg
+lip/GRID/s31/lwwj3a.mpg
+lip/GRID/s31/sgwnzp.mpg
+lip/GRID/s31/srbfzp.mpg
+lip/GRID/s31/pwat5s.mpg
+lip/GRID/s31/sbby6p.mpg
+lip/GRID/s31/lwab8n.mpg
+lip/GRID/s31/pwim8p.mpg
+lip/GRID/s31/bgid9a.mpg
+lip/GRID/s31/lwwp6p.mpg
+lip/GRID/s31/srbf1a.mpg
+lip/GRID/s31/bgik2p.mpg
+lip/GRID/s31/lwib4n.mpg
+lip/GRID/s31/lbbh6p.mpg
+lip/GRID/s31/sgwt4p.mpg
+lip/GRID/s31/swbz8p.mpg
+lip/GRID/s31/prwg8n.mpg
+lip/GRID/s31/prwt6n.mpg
+lip/GRID/s31/bbwd2p.mpg
+lip/GRID/s31/pgabzp.mpg
+lip/GRID/s31/pwbn7a.mpg
+lip/GRID/s31/lbig7s.mpg
+lip/GRID/s31/prat1a.mpg
+lip/GRID/s31/pgbu5s.mpg
+lip/GRID/s31/bbbj3a.mpg
+lip/GRID/s31/srwl8p.mpg
+lip/GRID/s31/lgipzp.mpg
+lip/GRID/s31/lrab4p.mpg
+lip/GRID/s31/sbiq3s.mpg
+lip/GRID/s31/bbii4p.mpg
+lip/GRID/s31/pbir8n.mpg
+lip/GRID/s31/lbin1s.mpg
+lip/GRID/s31/brbd3s.mpg
+lip/GRID/s31/bwwr2p.mpg
+lip/GRID/s31/prwa5s.mpg
+lip/GRID/s31/sbiq5a.mpg
+lip/GRID/s31/lgbp8p.mpg
+lip/GRID/s31/srae4n.mpg
+lip/GRID/s31/lriu2p.mpg
+lip/GRID/s31/sgwg7a.mpg
+lip/GRID/s31/lgap3s.mpg
+lip/GRID/s31/bbbc6n.mpg
+lip/GRID/s31/brwy1a.mpg
+lip/GRID/s31/pgan8p.mpg
+lip/GRID/s31/lwbc4p.mpg
+lip/GRID/s31/pgah5a.mpg
+lip/GRID/s31/srir1a.mpg
+lip/GRID/s31/primzn.mpg
+lip/GRID/s31/lgbj4p.mpg
+lip/GRID/s31/bbwj4n.mpg
+lip/GRID/s31/bgay4p.mpg
+lip/GRID/s31/sbid5s.mpg
+lip/GRID/s31/sbwr6p.mpg
+lip/GRID/s31/srbl5a.mpg
+lip/GRID/s31/srik4n.mpg
+lip/GRID/s31/lwiu8p.mpg
+lip/GRID/s31/sray6n.mpg
+lip/GRID/s31/sgbm6p.mpg
+lip/GRID/s31/bwbq6n.mpg
+lip/GRID/s31/lgio9s.mpg
+lip/GRID/s31/brwd9a.mpg
+lip/GRID/s31/bbav6p.mpg
+lip/GRID/s31/sbik1a.mpg
+lip/GRID/s31/sriq8n.mpg
+lip/GRID/s31/pgihzp.mpg
+lip/GRID/s31/lwwc6n.mpg
+lip/GRID/s31/bwax6n.mpg
+lip/GRID/s31/lwwx1a.mpg
+lip/GRID/s31/pwwu3s.mpg
+lip/GRID/s31/sbix7s.mpg
+lip/GRID/s31/lrwv5a.mpg
+lip/GRID/s31/lbbh4n.mpg
+lip/GRID/s31/bgwz3a.mpg
+lip/GRID/s31/pgah3s.mpg
+lip/GRID/s31/lbit7a.mpg
+lip/GRID/s31/bwix3s.mpg
+lip/GRID/s31/pgbh7s.mpg
+lip/GRID/s31/sgaf7s.mpg
+lip/GRID/s31/brbj8p.mpg
+lip/GRID/s31/bbiv2p.mpg
+lip/GRID/s31/srwz6p.mpg
+lip/GRID/s31/bbii5a.mpg
+lip/GRID/s31/lwii1a.mpg
+lip/GRID/s31/pbwg5a.mpg
+lip/GRID/s31/lwwp4n.mpg
+lip/GRID/s31/lwiu9a.mpg
+lip/GRID/s31/bwip8n.mpg
+lip/GRID/s31/sbwl1s.mpg
+lip/GRID/s31/pwbh1s.mpg
+lip/GRID/s31/brbq3a.mpg
+lip/GRID/s31/pwia1a.mpg
+lip/GRID/s31/lrwc3a.mpg
+lip/GRID/s31/bbac5a.mpg
+lip/GRID/s31/sbbr1s.mpg
+lip/GRID/s31/sbwe7s.mpg
+lip/GRID/s31/bgix8n.mpg
+lip/GRID/s31/sgil7s.mpg
+lip/GRID/s31/bbio7s.mpg
+lip/GRID/s31/sbwy8n.mpg
+lip/GRID/s31/brwx9s.mpg
+lip/GRID/s31/lgbdzp.mpg
+lip/GRID/s31/sgis3a.mpg
+lip/GRID/s31/brip3s.mpg
+lip/GRID/s31/lwbv7a.mpg
+lip/GRID/s31/lwao6n.mpg
+lip/GRID/s31/swbs4p.mpg
+lip/GRID/s31/lriu1s.mpg
+lip/GRID/s31/lgii4n.mpg
+lip/GRID/s31/brbj9a.mpg
+lip/GRID/s31/swbz9a.mpg
+lip/GRID/s31/sbbrzn.mpg
+lip/GRID/s31/lribzp.mpg
+lip/GRID/s31/sbby7a.mpg
+lip/GRID/s31/lgbc9s.mpg
+lip/GRID/s31/lwwv9s.mpg
+lip/GRID/s31/lwwjzn.mpg
+lip/GRID/s31/srwl7s.mpg
+lip/GRID/s31/bbwj5s.mpg
+lip/GRID/s31/lgiczn.mpg
+lip/GRID/s31/sgbm5s.mpg
+lip/GRID/s31/pwanzn.mpg
+lip/GRID/s31/brac8n.mpg
+lip/GRID/s31/sgiz5s.mpg
+lip/GRID/s31/swal6p.mpg
+lip/GRID/s31/pwwn9s.mpg
+lip/GRID/s31/sgil8p.mpg
+lip/GRID/s31/srae7a.mpg
+lip/GRID/s31/pgwu8n.mpg
+lip/GRID/s31/bbwx5a.mpg
+lip/GRID/s31/pgia6p.mpg
+lip/GRID/s31/prbg4n.mpg
+lip/GRID/s31/swbf7a.mpg
+lip/GRID/s31/pgauzn.mpg
+lip/GRID/s31/lrau7a.mpg
+lip/GRID/s31/lriu3a.mpg
+lip/GRID/s31/pwba9a.mpg
+lip/GRID/s31/lrbi1s.mpg
+lip/GRID/s31/lgic2p.mpg
+lip/GRID/s31/lbauzp.mpg
+lip/GRID/s31/bgbr2n.mpg
+lip/GRID/s31/lbah1s.mpg
+lip/GRID/s31/bbai7s.mpg
+lip/GRID/s31/briv7s.mpg
+lip/GRID/s31/bgarzp.mpg
+lip/GRID/s31/bwak1a.mpg
+lip/GRID/s31/brap8p.mpg

data/unseen_val.txt

@@ -0,0 +1,2593 @@
+lip/GRID/s1/bbaf2n.mpg
+lip/GRID/s1/bbaf3s.mpg
+lip/GRID/s1/bbaf4p.mpg
+lip/GRID/s1/bbas1s.mpg
+lip/GRID/s1/bbaz4n.mpg
+lip/GRID/s1/bbaz7a.mpg
+lip/GRID/s1/bbbf7s.mpg
+lip/GRID/s1/bbbf8p.mpg
+lip/GRID/s1/bbbm1s.mpg
+lip/GRID/s1/bbbs6p.mpg
+lip/GRID/s1/bbbz9s.mpg
+lip/GRID/s1/bbil4p.mpg
+lip/GRID/s1/bbil5a.mpg
+lip/GRID/s1/bbwg1s.mpg
+lip/GRID/s1/bbwg3a.mpg
+lip/GRID/s1/bbwm7a.mpg
+lip/GRID/s1/bbws8n.mpg
+lip/GRID/s1/bgaa8p.mpg
+lip/GRID/s1/bgah2p.mpg
+lip/GRID/s1/bgbh6p.mpg
+lip/GRID/s1/bgbn8n.mpg
+lip/GRID/s1/bgia2n.mpg
+lip/GRID/s1/bgia3s.mpg
+lip/GRID/s1/bgin3a.mpg
+lip/GRID/s1/bgit4n.mpg
+lip/GRID/s1/bgit5s.mpg
+lip/GRID/s1/bgit6p.mpg
+lip/GRID/s1/bgwo3s.mpg
+lip/GRID/s1/bgwu6n.mpg
+lip/GRID/s1/bgwu9a.mpg
+lip/GRID/s1/bram2n.mpg
+lip/GRID/s1/bram4p.mpg
+lip/GRID/s1/bras9a.mpg
+lip/GRID/s1/brbg3s.mpg
+lip/GRID/s1/brbm6n.mpg
+lip/GRID/s1/brbm9a.mpg
+lip/GRID/s1/brif6p.mpg
+lip/GRID/s1/bris5a.mpg
+lip/GRID/s1/briz7s.mpg
+lip/GRID/s1/brwa5a.mpg
+lip/GRID/s1/brwn1s.mpg
+lip/GRID/s1/brwt4n.mpg
+lip/GRID/s1/brwt6p.mpg
+lip/GRID/s1/bwag6p.mpg
+lip/GRID/s1/bwat4p.mpg
+lip/GRID/s1/bwbg8n.mpg
+lip/GRID/s1/bwbhzp.mpg
+lip/GRID/s1/bwigzn.mpg
+lip/GRID/s1/bwit1a.mpg
+lip/GRID/s1/bwwa9s.mpg
+lip/GRID/s1/bwwh2n.mpg
+lip/GRID/s1/bwwh3s.mpg
+lip/GRID/s1/bwwu1s.mpg
+lip/GRID/s1/bwwu2p.mpg
+lip/GRID/s1/bwwu3a.mpg
+lip/GRID/s1/lbax8n.mpg
+lip/GRID/s1/lbay1a.mpg
+lip/GRID/s1/lbbr1a.mpg
+lip/GRID/s1/lbij7s.mpg
+lip/GRID/s1/lbij9a.mpg
+lip/GRID/s1/lbiq2p.mpg
+lip/GRID/s1/lbiq3a.mpg
+lip/GRID/s1/lbwe7a.mpg
+lip/GRID/s1/lbwr2n.mpg
+lip/GRID/s1/lgaf5s.mpg
+lip/GRID/s1/lgas3s.mpg
+lip/GRID/s1/lgas5a.mpg
+lip/GRID/s1/lgaz6n.mpg
+lip/GRID/s1/lgbf9s.mpg
+lip/GRID/s1/lgbm3s.mpg
+lip/GRID/s1/lgbm5a.mpg
+lip/GRID/s1/lgil7a.mpg
+lip/GRID/s1/lgis1a.mpg
+lip/GRID/s1/lgwm7s.mpg
+lip/GRID/s1/lgwm8p.mpg
+lip/GRID/s1/lrae4p.mpg
+lip/GRID/s1/lrae5a.mpg
+lip/GRID/s1/lrak6n.mpg
+lip/GRID/s1/lrak7s.mpg
+lip/GRID/s1/lrak9a.mpg
+lip/GRID/s1/lray5s.mpg
+lip/GRID/s1/lray6p.mpg
+lip/GRID/s1/lrbr7a.mpg
+lip/GRID/s1/lrby8n.mpg
+lip/GRID/s1/lriezp.mpg
+lip/GRID/s1/lriq7s.mpg
+lip/GRID/s1/lrwf1s.mpg
+lip/GRID/s1/lrwl4n.mpg
+lip/GRID/s1/lrwl7a.mpg
+lip/GRID/s1/lrws1a.mpg
+lip/GRID/s1/lrwz2n.mpg
+lip/GRID/s1/lrwz5a.mpg
+lip/GRID/s1/lwal3s.mpg
+lip/GRID/s1/lwaz2p.mpg
+lip/GRID/s1/lwbl6n.mpg
+lip/GRID/s1/lwbz6p.mpg
+lip/GRID/s1/lwiy6n.mpg
+lip/GRID/s1/lwwm2p.mpg
+lip/GRID/s1/lwwz8n.mpg
+lip/GRID/s1/pbao8n.mpg
+lip/GRID/s1/pbib8p.mpg
+lip/GRID/s1/pbio6p.mpg
+lip/GRID/s1/pbiv1a.mpg
+lip/GRID/s1/pbwc8n.mpg
+lip/GRID/s1/pbwj4p.mpg
+lip/GRID/s1/pbwp8p.mpg
+lip/GRID/s1/pgad9s.mpg
+lip/GRID/s1/pgak2n.mpg
+lip/GRID/s1/pgay1s.mpg
+lip/GRID/s1/pgbrzn.mpg
+lip/GRID/s1/pgiq3s.mpg
+lip/GRID/s1/pgix6n.mpg
+lip/GRID/s1/pgix9a.mpg
+lip/GRID/s1/pgwe9a.mpg
+lip/GRID/s1/pgwl3a.mpg
+lip/GRID/s1/pgwy8n.mpg
+lip/GRID/s1/prac8p.mpg
+lip/GRID/s1/prap6p.mpg
+lip/GRID/s1/prav8n.mpg
+lip/GRID/s1/prav9s.mpg
+lip/GRID/s1/praxzp.mpg
+lip/GRID/s1/prbd1s.mpg
+lip/GRID/s1/prbj7a.mpg
+lip/GRID/s1/prbp9s.mpg
+lip/GRID/s1/pric2n.mpg
+lip/GRID/s1/pric5a.mpg
+lip/GRID/s1/prii6n.mpg
+lip/GRID/s1/pripzn.mpg
+lip/GRID/s1/prwd4n.mpg
+lip/GRID/s1/prwd5s.mpg
+lip/GRID/s1/prwd7a.mpg
+lip/GRID/s1/prwx6n.mpg
+lip/GRID/s1/prwx8p.mpg
+lip/GRID/s1/pwad2n.mpg
+lip/GRID/s1/pwaq2p.mpg
+lip/GRID/s1/pwaqzn.mpg
+lip/GRID/s1/pwax5s.mpg
+lip/GRID/s1/pwbd7s.mpg
+lip/GRID/s1/pwbkzn.mpg
+lip/GRID/s1/pwbq4n.mpg
+lip/GRID/s1/pwbq6p.mpg
+lip/GRID/s1/pwic8n.mpg
+lip/GRID/s1/pwic9s.mpg
+lip/GRID/s1/pwip7s.mpg
+lip/GRID/s1/pwix2p.mpg
+lip/GRID/s1/pwix3a.mpg
+lip/GRID/s1/pwwe3a.mpg
+lip/GRID/s1/pwwk5s.mpg
+lip/GRID/s1/sbaa4n.mpg
+lip/GRID/s1/sbaa6p.mpg
+lip/GRID/s1/sbag8n.mpg
+lip/GRID/s1/sbahzp.mpg
+lip/GRID/s1/sban2n.mpg
+lip/GRID/s1/sban3s.mpg
+lip/GRID/s1/sbba9s.mpg
+lip/GRID/s1/sbbh2n.mpg
+lip/GRID/s1/sbbh3s.mpg
+lip/GRID/s1/sbbn9a.mpg
+lip/GRID/s1/sbbuzn.mpg
+lip/GRID/s1/sbig5s.mpg
+lip/GRID/s1/sbit3s.mpg
+lip/GRID/s1/sbit4p.mpg
+lip/GRID/s1/sbwb2n.mpg
+lip/GRID/s1/sbwh6n.mpg
+lip/GRID/s1/sbwo1s.mpg
+lip/GRID/s1/sbwo3a.mpg
+lip/GRID/s1/sbwozn.mpg
+lip/GRID/s1/sgai6n.mpg
+lip/GRID/s1/sgai9a.mpg
+lip/GRID/s1/sgap1s.mpg
+lip/GRID/s1/sgap3a.mpg
+lip/GRID/s1/sgav4n.mpg
+lip/GRID/s1/sgav6p.mpg
+lip/GRID/s1/sgbc7s.mpg
+lip/GRID/s1/sgbj3a.mpg
+lip/GRID/s1/sgbjzn.mpg
+lip/GRID/s1/sgbxzp.mpg
+lip/GRID/s1/sgib8n.mpg
+lip/GRID/s1/sgiv2p.mpg
+lip/GRID/s1/sgiv3a.mpg
+lip/GRID/s1/sgwd1s.mpg
+lip/GRID/s1/sgwj6p.mpg
+lip/GRID/s1/sgwp9s.mpg
+lip/GRID/s1/sgwx2n.mpg
+lip/GRID/s1/sgwx4p.mpg
+lip/GRID/s1/srah5s.mpg
+lip/GRID/s1/srbb6p.mpg
+lip/GRID/s1/sria9a.mpg
+lip/GRID/s1/srwc1a.mpg
+lip/GRID/s1/srwi2n.mpg
+lip/GRID/s1/srwi5a.mpg
+lip/GRID/s1/srwo7s.mpg
+lip/GRID/s1/srwv3a.mpg
+lip/GRID/s1/swao4n.mpg
+lip/GRID/s1/swao6p.mpg
+lip/GRID/s1/swavzp.mpg
+lip/GRID/s1/swbv5a.mpg
+lip/GRID/s1/swib2n.mpg
+lip/GRID/s1/swiu4n.mpg
+lip/GRID/s1/swiu6p.mpg
+lip/GRID/s1/swwi9s.mpg
+lip/GRID/s1/swwp3s.mpg
+lip/GRID/s1/swwv6n.mpg
+lip/GRID/s16/bbak1n.mpg
+lip/GRID/s16/bbak2s.mpg
+lip/GRID/s16/bbbe2s.mpg
+lip/GRID/s16/bbbk5n.mpg
+lip/GRID/s16/bbbk8a.mpg
+lip/GRID/s16/bbbr2a.mpg
+lip/GRID/s16/bbby3n.mpg
+lip/GRID/s16/bbij8s.mpg
+lip/GRID/s16/bbiq1n.mpg
+lip/GRID/s16/bbiq4a.mpg
+lip/GRID/s16/bbix5n.mpg
+lip/GRID/s16/bbwe8a.mpg
+lip/GRID/s16/bbwr5p.mpg
+lip/GRID/s16/bgaf5n.mpg
+lip/GRID/s16/bgamzs.mpg
+lip/GRID/s16/bgas5p.mpg
+lip/GRID/s16/bgaz8s.mpg
+lip/GRID/s16/bgaz9p.mpg
+lip/GRID/s16/bgbf9n.mpg
+lip/GRID/s16/bgbs7n.mpg
+lip/GRID/s16/bgbtza.mpg
+lip/GRID/s16/bgif2s.mpg
+lip/GRID/s16/bgil5n.mpg
+lip/GRID/s16/bgil6s.mpg
+lip/GRID/s16/bgwazs.mpg
+lip/GRID/s16/bgwg4s.mpg
+lip/GRID/s16/bgwt1n.mpg
+lip/GRID/s16/bgwt4a.mpg
+lip/GRID/s16/brak7n.mpg
+lip/GRID/s16/brar1n.mpg
+lip/GRID/s16/brbl2s.mpg
+lip/GRID/s16/brbl4a.mpg
+lip/GRID/s16/brbr5n.mpg
+lip/GRID/s16/brbr8a.mpg
+lip/GRID/s16/brby9n.mpg
+lip/GRID/s16/brbz1p.mpg
+lip/GRID/s16/brik3n.mpg
+lip/GRID/s16/brik5p.mpg
+lip/GRID/s16/briq7n.mpg
+lip/GRID/s16/briy3p.mpg
+lip/GRID/s16/brwl6s.mpg
+lip/GRID/s16/brwl8a.mpg
+lip/GRID/s16/brwz4s.mpg
+lip/GRID/s16/brwz5p.mpg
+lip/GRID/s16/bwafzs.mpg
+lip/GRID/s16/bwaz2s.mpg
+lip/GRID/s16/bwaz4a.mpg
+lip/GRID/s16/bwbf5p.mpg
+lip/GRID/s16/bwbs1n.mpg
+lip/GRID/s16/bwbz7p.mpg
+lip/GRID/s16/bwie7p.mpg
+lip/GRID/s16/bwil2a.mpg
+lip/GRID/s16/bwilzs.mpg
+lip/GRID/s16/bwwf7n.mpg
+lip/GRID/s16/bwws7p.mpg
+lip/GRID/s16/lbac2s.mpg
+lip/GRID/s16/lbap1p.mpg
+lip/GRID/s16/lbbc6s.mpg
+lip/GRID/s16/lbbi9n.mpg
+lip/GRID/s16/lbbjzs.mpg
+lip/GRID/s16/lbbxza.mpg
+lip/GRID/s16/lbicza.mpg
+lip/GRID/s16/lbii1n.mpg
+lip/GRID/s16/lbivzs.mpg
+lip/GRID/s16/lbwp7n.mpg
+lip/GRID/s16/lgak4s.mpg
+lip/GRID/s16/lgaq8s.mpg
+lip/GRID/s16/lgbe6a.mpg
+lip/GRID/s16/lgbr4a.mpg
+lip/GRID/s16/lgby7p.mpg
+lip/GRID/s16/lgby8a.mpg
+lip/GRID/s16/lgid8a.mpg
+lip/GRID/s16/lgij9n.mpg
+lip/GRID/s16/lgik2a.mpg
+lip/GRID/s16/lgix7n.mpg
+lip/GRID/s16/lgwl3p.mpg
+lip/GRID/s16/lgwr5n.mpg
+lip/GRID/s16/lgwr8a.mpg
+lip/GRID/s16/lrac7n.mpg
+lip/GRID/s16/lraj4a.mpg
+lip/GRID/s16/lrap6s.mpg
+lip/GRID/s16/lrap8a.mpg
+lip/GRID/s16/lrbd3p.mpg
+lip/GRID/s16/lrbx4s.mpg
+lip/GRID/s16/lric3n.mpg
+lip/GRID/s16/lrip1n.mpg
+lip/GRID/s16/lrip4a.mpg
+lip/GRID/s16/lrwd6s.mpg
+lip/GRID/s16/lrwq5p.mpg
+lip/GRID/s16/lrwq6a.mpg
+lip/GRID/s16/lwakza.mpg
+lip/GRID/s16/lwaq4a.mpg
+lip/GRID/s16/lwax7p.mpg
+lip/GRID/s16/lwbq6s.mpg
+lip/GRID/s16/lwbq7p.mpg
+lip/GRID/s16/lwic9n.mpg
+lip/GRID/s16/lwwe3p.mpg
+lip/GRID/s16/lwwy6a.mpg
+lip/GRID/s16/pbaa8a.mpg
+lip/GRID/s16/pban6a.mpg
+lip/GRID/s16/pbat9p.mpg
+lip/GRID/s16/pbbh3n.mpg
+lip/GRID/s16/pbbn8s.mpg
+lip/GRID/s16/pbit3n.mpg
+lip/GRID/s16/pbwb5p.mpg
+lip/GRID/s16/pbwh7n.mpg
+lip/GRID/s16/pbwh8s.mpg
+lip/GRID/s16/pbwo1n.mpg
+lip/GRID/s16/pbwu6s.mpg
+lip/GRID/s16/pgbp8a.mpg
+lip/GRID/s16/pgbx1p.mpg
+lip/GRID/s16/pgbxzs.mpg
+lip/GRID/s16/pgii6a.mpg
+lip/GRID/s16/pgwd2s.mpg
+lip/GRID/s16/pgwj6s.mpg
+lip/GRID/s16/prab1n.mpg
+lip/GRID/s16/prah6s.mpg
+lip/GRID/s16/prah7p.mpg
+lip/GRID/s16/pran9n.mpg
+lip/GRID/s16/prau3n.mpg
+lip/GRID/s16/prbh9n.mpg
+lip/GRID/s16/prih3p.mpg
+lip/GRID/s16/prih4a.mpg
+lip/GRID/s16/prin8a.mpg
+lip/GRID/s16/priu2a.mpg
+lip/GRID/s16/prwczs.mpg
+lip/GRID/s16/prwo8s.mpg
+lip/GRID/s16/prwv3p.mpg
+lip/GRID/s16/pwacza.mpg
+lip/GRID/s16/pwao6s.mpg
+lip/GRID/s16/pwav1p.mpg
+lip/GRID/s16/pwbc2s.mpg
+lip/GRID/s16/pwbc3p.mpg
+lip/GRID/s16/pwbi5n.mpg
+lip/GRID/s16/pwbv3n.mpg
+lip/GRID/s16/pwih7n.mpg
+lip/GRID/s16/pwiu6s.mpg
+lip/GRID/s16/pwwc7p.mpg
+lip/GRID/s16/pwwj2a.mpg
+lip/GRID/s16/pwwxza.mpg
+lip/GRID/s16/sbaf5p.mpg
+lip/GRID/s16/sbamza.mpg
+lip/GRID/s16/sbas1n.mpg
+lip/GRID/s16/sbaz5n.mpg
+lip/GRID/s16/sbaz6s.mpg
+lip/GRID/s16/sbbf8s.mpg
+lip/GRID/s16/sbbm2s.mpg
+lip/GRID/s16/sbbs6s.mpg
+lip/GRID/s16/sbbs7p.mpg
+lip/GRID/s16/sbil6a.mpg
+lip/GRID/s16/sbiz2s.mpg
+lip/GRID/s16/sbiz4a.mpg
+lip/GRID/s16/sbwg1n.mpg
+lip/GRID/s16/sbwg4a.mpg
+lip/GRID/s16/sbwtzs.mpg
+lip/GRID/s16/sgah2s.mpg
+lip/GRID/s16/sgau1p.mpg
+lip/GRID/s16/sgbb1n.mpg
+lip/GRID/s16/sgbo1p.mpg
+lip/GRID/s16/sgia4s.mpg
+lip/GRID/s16/sgig8s.mpg
+lip/GRID/s16/sgihza.mpg
+lip/GRID/s16/sgin1n.mpg
+lip/GRID/s16/sgin2s.mpg
+lip/GRID/s16/sgwo3n.mpg
+lip/GRID/s16/sgwu7n.mpg
+lip/GRID/s16/sram3n.mpg
+lip/GRID/s16/srba1p.mpg
+lip/GRID/s16/srbazs.mpg
+lip/GRID/s16/srif8a.mpg
+lip/GRID/s16/sris5p.mpg
+lip/GRID/s16/sris6a.mpg
+lip/GRID/s16/srwhza.mpg
+lip/GRID/s16/srwn2s.mpg
+lip/GRID/s16/srwn3p.mpg
+lip/GRID/s16/srwn4a.mpg
+lip/GRID/s16/srwt5n.mpg
+lip/GRID/s16/srwt6s.mpg
+lip/GRID/s16/srwt7p.mpg
+lip/GRID/s16/srwt8a.mpg
+lip/GRID/s16/swaa1n.mpg
+lip/GRID/s16/swag8a.mpg
+lip/GRID/s16/swan2a.mpg
+lip/GRID/s16/swbhzs.mpg
+lip/GRID/s16/swbn3n.mpg
+lip/GRID/s16/swbn5p.mpg
+lip/GRID/s16/swbn6a.mpg
+lip/GRID/s16/swbt7n.mpg
+lip/GRID/s16/swig1n.mpg
+lip/GRID/s16/swwoza.mpg
+lip/GRID/s16/swwu3p.mpg
+lip/GRID/s17/bbak1s.mpg
+lip/GRID/s17/bbak2p.mpg
+lip/GRID/s17/bbayzp.mpg
+lip/GRID/s17/bbbk4n.mpg
+lip/GRID/s17/bbbr1a.mpg
+lip/GRID/s17/bbid2n.mpg
+lip/GRID/s17/bbid4p.mpg
+lip/GRID/s17/bbiqzn.mpg
+lip/GRID/s17/bbwr3s.mpg
+lip/GRID/s17/bbwr4p.mpg
+lip/GRID/s17/bbwr5a.mpg
+lip/GRID/s17/bgaf6p.mpg
+lip/GRID/s17/bgam1a.mpg
+lip/GRID/s17/bgamzp.mpg
+lip/GRID/s17/bgas2n.mpg
+lip/GRID/s17/bgas3s.mpg
+lip/GRID/s17/bgaz7s.mpg
+lip/GRID/s17/bgaz8p.mpg
+lip/GRID/s17/bgbm2n.mpg
+lip/GRID/s17/bgbm3s.mpg
+lip/GRID/s17/bgbm4p.mpg
+lip/GRID/s17/bgbm5a.mpg
+lip/GRID/s17/bgif2p.mpg
+lip/GRID/s17/bgif3a.mpg
+lip/GRID/s17/bgir9s.mpg
+lip/GRID/s17/bgwm7s.mpg
+lip/GRID/s17/bgwt1s.mpg
+lip/GRID/s17/bgwt3a.mpg
+lip/GRID/s17/brae2n.mpg
+lip/GRID/s17/brae5a.mpg
+lip/GRID/s17/brak7s.mpg
+lip/GRID/s17/brarzn.mpg
+lip/GRID/s17/bray4n.mpg
+lip/GRID/s17/brbe7s.mpg
+lip/GRID/s17/brid8n.mpg
+lip/GRID/s17/brik3s.mpg
+lip/GRID/s17/brwl7a.mpg
+lip/GRID/s17/brwr9s.mpg
+lip/GRID/s17/bwae9s.mpg
+lip/GRID/s17/bwaz1s.mpg
+lip/GRID/s17/bwaz2p.mpg
+lip/GRID/s17/bwbf4p.mpg
+lip/GRID/s17/bwbl8p.mpg
+lip/GRID/s17/bwir4p.mpg
+lip/GRID/s17/bwwm3a.mpg
+lip/GRID/s17/bwws7a.mpg
+lip/GRID/s17/lbao8n.mpg
+lip/GRID/s17/lbao9s.mpg
+lip/GRID/s17/lbapzp.mpg
+lip/GRID/s17/lbav3s.mpg
+lip/GRID/s17/lbbp3s.mpg
+lip/GRID/s17/lbbv7s.mpg
+lip/GRID/s17/lbbv8p.mpg
+lip/GRID/s17/lbbv9a.mpg
+lip/GRID/s17/lbii3a.mpg
+lip/GRID/s17/lbio6p.mpg
+lip/GRID/s17/lbio7a.mpg
+lip/GRID/s17/lbwp6n.mpg
+lip/GRID/s17/lbwxzn.mpg
+lip/GRID/s17/lgaezp.mpg
+lip/GRID/s17/lgaq8p.mpg
+lip/GRID/s17/lgay1s.mpg
+lip/GRID/s17/lgay2p.mpg
+lip/GRID/s17/lgbe4p.mpg
+lip/GRID/s17/lgbe5a.mpg
+lip/GRID/s17/lgbk9a.mpg
+lip/GRID/s17/lgikzp.mpg
+lip/GRID/s17/lgiq5a.mpg
+lip/GRID/s17/lgwe7s.mpg
+lip/GRID/s17/lgwe8p.mpg
+lip/GRID/s17/lgwr5s.mpg
+lip/GRID/s17/lgwy8n.mpg
+lip/GRID/s17/lgwy9s.mpg
+lip/GRID/s17/lgwzzp.mpg
+lip/GRID/s17/lrac6n.mpg
+lip/GRID/s17/lrap5s.mpg
+lip/GRID/s17/lrbd1s.mpg
+lip/GRID/s17/lrbdzn.mpg
+lip/GRID/s17/lrbx5a.mpg
+lip/GRID/s17/lric2n.mpg
+lip/GRID/s17/lric3s.mpg
+lip/GRID/s17/lriv5s.mpg
+lip/GRID/s17/lrwd5s.mpg
+lip/GRID/s17/lrwj9s.mpg
+lip/GRID/s17/lrwkzp.mpg
+lip/GRID/s17/lwad2n.mpg
+lip/GRID/s17/lwaj8p.mpg
+lip/GRID/s17/lwaq3a.mpg
+lip/GRID/s17/lwax4n.mpg
+lip/GRID/s17/lwbd6n.mpg
+lip/GRID/s17/lwbd9a.mpg
+lip/GRID/s17/lwbkzn.mpg
+lip/GRID/s17/lwbx8n.mpg
+lip/GRID/s17/lwbyzp.mpg
+lip/GRID/s17/lwic9s.mpg
+lip/GRID/s17/lwij2n.mpg
+lip/GRID/s17/lwip6n.mpg
+lip/GRID/s17/lwip9a.mpg
+lip/GRID/s17/lwix2p.mpg
+lip/GRID/s17/lwwe2p.mpg
+lip/GRID/s17/lwwe3a.mpg
+lip/GRID/s17/lwwezn.mpg
+lip/GRID/s17/lwwq9s.mpg
+lip/GRID/s17/lwwy4p.mpg
+lip/GRID/s17/pbaa4n.mpg
+lip/GRID/s17/pbaa5s.mpg
+lip/GRID/s17/pbaa6p.mpg
+lip/GRID/s17/pbag8n.mpg
+lip/GRID/s17/pbah1a.mpg
+lip/GRID/s17/pbbh2n.mpg
+lip/GRID/s17/pbbn6n.mpg
+lip/GRID/s17/pbbn8p.mpg
+lip/GRID/s17/pbia2p.mpg
+lip/GRID/s17/pbig4n.mpg
+lip/GRID/s17/pbit2n.mpg
+lip/GRID/s17/pbwb2n.mpg
+lip/GRID/s17/pbwozn.mpg
+lip/GRID/s17/pgai6n.mpg
+lip/GRID/s17/pgbc6n.mpg
+lip/GRID/s17/pgbc9a.mpg
+lip/GRID/s17/pgbj1s.mpg
+lip/GRID/s17/pgiczp.mpg
+lip/GRID/s17/pgii2n.mpg
+lip/GRID/s17/pgii3s.mpg
+lip/GRID/s17/pgwd1s.mpg
+lip/GRID/s17/pgwj4n.mpg
+lip/GRID/s17/pgwp8n.mpg
+lip/GRID/s17/pgwx4p.mpg
+lip/GRID/s17/pgwx5a.mpg
+lip/GRID/s17/prab2p.mpg
+lip/GRID/s17/prau5a.mpg
+lip/GRID/s17/prbo5a.mpg
+lip/GRID/s17/pria7s.mpg
+lip/GRID/s17/pria9a.mpg
+lip/GRID/s17/prin6p.mpg
+lip/GRID/s17/prit8n.mpg
+lip/GRID/s17/priuzp.mpg
+lip/GRID/s17/pwab7s.mpg
+lip/GRID/s17/pwab8p.mpg
+lip/GRID/s17/pwao6p.mpg
+lip/GRID/s17/pwau9s.mpg
+lip/GRID/s17/pwbc1s.mpg
+lip/GRID/s17/pwbc3a.mpg
+lip/GRID/s17/pwbi4n.mpg
+lip/GRID/s17/pwbi7a.mpg
+lip/GRID/s17/pwbp1a.mpg
+lip/GRID/s17/pwib3s.mpg
+lip/GRID/s17/pwih6n.mpg
+lip/GRID/s17/pwih9a.mpg
+lip/GRID/s17/pwiu4n.mpg
+lip/GRID/s17/pwiu6p.mpg
+lip/GRID/s17/pwiu7a.mpg
+lip/GRID/s17/pwwi8n.mpg
+lip/GRID/s17/pwwv9a.mpg
+lip/GRID/s17/sbaf3s.mpg
+lip/GRID/s17/sbaf4p.mpg
+lip/GRID/s17/sbas2p.mpg
+lip/GRID/s17/sbas3a.mpg
+lip/GRID/s17/sbaz4n.mpg
+lip/GRID/s17/sbaz7a.mpg
+lip/GRID/s17/sbbf9a.mpg
+lip/GRID/s17/sbbm2p.mpg
+lip/GRID/s17/sbbm3a.mpg
+lip/GRID/s17/sbbmzn.mpg
+lip/GRID/s17/sbbz9s.mpg
+lip/GRID/s17/sbie8n.mpg
+lip/GRID/s17/sbil2n.mpg
+lip/GRID/s17/sbil3s.mpg
+lip/GRID/s17/sbil4p.mpg
+lip/GRID/s17/sbil5a.mpg
+lip/GRID/s17/sbwg1s.mpg
+lip/GRID/s17/sbwgzn.mpg
+lip/GRID/s17/sbwm6p.mpg
+lip/GRID/s17/sgah2p.mpg
+lip/GRID/s17/sgan7a.mpg
+lip/GRID/s17/sgat9s.mpg
+lip/GRID/s17/sgau1a.mpg
+lip/GRID/s17/sgbbzn.mpg
+lip/GRID/s17/sgbh7a.mpg
+lip/GRID/s17/sgbozp.mpg
+lip/GRID/s17/sgbu3s.mpg
+lip/GRID/s17/sgia2n.mpg
+lip/GRID/s17/sgia5a.mpg
+lip/GRID/s17/sgig6n.mpg
+lip/GRID/s17/sgin1s.mpg
+lip/GRID/s17/sgwb4n.mpg
+lip/GRID/s17/sgwb6p.mpg
+lip/GRID/s17/sgwi1a.mpg
+lip/GRID/s17/sraf9s.mpg
+lip/GRID/s17/sragzp.mpg
+lip/GRID/s17/sram2n.mpg
+lip/GRID/s17/sras7s.mpg
+lip/GRID/s17/srba1a.mpg
+lip/GRID/s17/srbg2n.mpg
+lip/GRID/s17/srbm6n.mpg
+lip/GRID/s17/sris2n.mpg
+lip/GRID/s17/srwa3s.mpg
+lip/GRID/s17/srwg8p.mpg
+lip/GRID/s17/srwt5s.mpg
+lip/GRID/s17/swaazn.mpg
+lip/GRID/s17/swag7a.mpg
+lip/GRID/s17/swat2n.mpg
+lip/GRID/s17/swat4p.mpg
+lip/GRID/s17/swbg8n.mpg
+lip/GRID/s17/swbh1a.mpg
+lip/GRID/s17/swbn4p.mpg
+lip/GRID/s17/swbt7s.mpg
+lip/GRID/s17/swbt9a.mpg
+lip/GRID/s17/swigzn.mpg
+lip/GRID/s17/swim4n.mpg
+lip/GRID/s17/swim7a.mpg
+lip/GRID/s17/swwa9s.mpg
+lip/GRID/s17/swwu2p.mpg
+lip/GRID/s2/bbaf2s.mpg
+lip/GRID/s2/bbal5n.mpg
+lip/GRID/s2/bbal6s.mpg
+lip/GRID/s2/bbaszs.mpg
+lip/GRID/s2/bbaz4s.mpg
+lip/GRID/s2/bbbm2a.mpg
+lip/GRID/s2/bbie9p.mpg
+lip/GRID/s2/bbir6s.mpg
+lip/GRID/s2/bbiz1p.mpg
+lip/GRID/s2/bgaa5n.mpg
+lip/GRID/s2/bgaa6s.mpg
+lip/GRID/s2/bgat8s.mpg
+lip/GRID/s2/bgat9p.mpg
+lip/GRID/s2/bgbh3n.mpg
+lip/GRID/s2/bgbh4s.mpg
+lip/GRID/s2/bgbh6a.mpg
+lip/GRID/s2/bgia2s.mpg
+lip/GRID/s2/bgig7p.mpg
+lip/GRID/s2/bgig8a.mpg
+lip/GRID/s2/bgim9n.mpg
+lip/GRID/s2/bgit5p.mpg
+lip/GRID/s2/bgit6a.mpg
+lip/GRID/s2/bgwh9p.mpg
+lip/GRID/s2/bram1n.mpg
+lip/GRID/s2/bras5n.mpg
+lip/GRID/s2/bras6s.mpg
+lip/GRID/s2/bras7p.mpg
+lip/GRID/s2/brbs9n.mpg
+lip/GRID/s2/brif6a.mpg
+lip/GRID/s2/brwa4a.mpg
+lip/GRID/s2/brwg6s.mpg
+lip/GRID/s2/brwt4s.mpg
+lip/GRID/s2/bwag4s.mpg
+lip/GRID/s2/bwag6a.mpg
+lip/GRID/s2/bwam7n.mpg
+lip/GRID/s2/bwam9p.mpg
+lip/GRID/s2/bwanza.mpg
+lip/GRID/s2/bwat2s.mpg
+lip/GRID/s2/bwba6a.mpg
+lip/GRID/s2/bwim3n.mpg
+lip/GRID/s2/bwim5p.mpg
+lip/GRID/s2/bwis8s.mpg
+lip/GRID/s2/bwwu1p.mpg
+lip/GRID/s2/bwwu2a.mpg
+lip/GRID/s2/lbad5n.mpg
+lip/GRID/s2/lbad7p.mpg
+lip/GRID/s2/lbaj9n.mpg
+lip/GRID/s2/lbbezs.mpg
+lip/GRID/s2/lbid1n.mpg
+lip/GRID/s2/lbid2s.mpg
+lip/GRID/s2/lbij8a.mpg
+lip/GRID/s2/lbiq2a.mpg
+lip/GRID/s2/lbiqzs.mpg
+lip/GRID/s2/lbix5p.mpg
+lip/GRID/s2/lbwe6a.mpg
+lip/GRID/s2/lbwlza.mpg
+lip/GRID/s2/lbwy6s.mpg
+lip/GRID/s2/lbwy7p.mpg
+lip/GRID/s2/lbwy8a.mpg
+lip/GRID/s2/lgaz5n.mpg
+lip/GRID/s2/lgbf7n.mpg
+lip/GRID/s2/lgbf9p.mpg
+lip/GRID/s2/lgbm2s.mpg
+lip/GRID/s2/lgbs6s.mpg
+lip/GRID/s2/lgif2a.mpg
+lip/GRID/s2/lgisza.mpg
+lip/GRID/s2/lgwt2a.mpg
+lip/GRID/s2/lrae1n.mpg
+lip/GRID/s2/lrae4a.mpg
+lip/GRID/s2/lrak7p.mpg
+lip/GRID/s2/lrbe5n.mpg
+lip/GRID/s2/lrbr6a.mpg
+lip/GRID/s2/lrby8s.mpg
+lip/GRID/s2/lrieza.mpg
+lip/GRID/s2/lriq7p.mpg
+lip/GRID/s2/lrwe9n.mpg
+lip/GRID/s2/lrwfzs.mpg
+lip/GRID/s2/lrwl4s.mpg
+lip/GRID/s2/lrwz2s.mpg
+lip/GRID/s2/lrwz3p.mpg
+lip/GRID/s2/lwae8s.mpg
+lip/GRID/s2/lwae9p.mpg
+lip/GRID/s2/lwafza.mpg
+lip/GRID/s2/lwal1n.mpg
+lip/GRID/s2/lwal4a.mpg
+lip/GRID/s2/lwar5n.mpg
+lip/GRID/s2/lwbl5n.mpg
+lip/GRID/s2/lwbs2a.mpg
+lip/GRID/s2/lwbz3n.mpg
+lip/GRID/s2/lwie5p.mpg
+lip/GRID/s2/lwik8s.mpg
+lip/GRID/s2/lwir1n.mpg
+lip/GRID/s2/lwir4a.mpg
+lip/GRID/s2/lwiy8a.mpg
+lip/GRID/s2/lwwz7n.mpg
+lip/GRID/s2/lwwz8s.mpg
+lip/GRID/s2/lwwz9p.mpg
+lip/GRID/s2/pbai3n.mpg
+lip/GRID/s2/pbao7n.mpg
+lip/GRID/s2/pbao8s.mpg
+lip/GRID/s2/pbav4a.mpg
+lip/GRID/s2/pbib8a.mpg
+lip/GRID/s2/pbiizs.mpg
+lip/GRID/s2/pbio4s.mpg
+lip/GRID/s2/pbiu9p.mpg
+lip/GRID/s2/pbwj3p.mpg
+lip/GRID/s2/pbwx1p.mpg
+lip/GRID/s2/pgad8s.mpg
+lip/GRID/s2/pgaq7p.mpg
+lip/GRID/s2/pgax9n.mpg
+lip/GRID/s2/pgayzs.mpg
+lip/GRID/s2/pgbe4a.mpg
+lip/GRID/s2/pgid4s.mpg
+lip/GRID/s2/pgij7n.mpg
+lip/GRID/s2/pgix6s.mpg
+lip/GRID/s2/prac8a.mpg
+lip/GRID/s2/prajzs.mpg
+lip/GRID/s2/prav9p.mpg
+lip/GRID/s2/prbdzs.mpg
+lip/GRID/s2/prbj5p.mpg
+lip/GRID/s2/prbp7n.mpg
+lip/GRID/s2/prbx1n.mpg
+lip/GRID/s2/prii6s.mpg
+lip/GRID/s2/prii7p.mpg
+lip/GRID/s2/prii8a.mpg
+lip/GRID/s2/prip1p.mpg
+lip/GRID/s2/priv6a.mpg
+lip/GRID/s2/prwj9p.mpg
+lip/GRID/s2/prwkza.mpg
+lip/GRID/s2/prwq4a.mpg
+lip/GRID/s2/pwaj8a.mpg
+lip/GRID/s2/pwaq1p.mpg
+lip/GRID/s2/pwax3n.mpg
+lip/GRID/s2/pwax4s.mpg
+lip/GRID/s2/pwax5p.mpg
+lip/GRID/s2/pwax6a.mpg
+lip/GRID/s2/pwbd7p.mpg
+lip/GRID/s2/pwbkzs.mpg
+lip/GRID/s2/pwbyza.mpg
+lip/GRID/s2/pwic8s.mpg
+lip/GRID/s2/pwij1n.mpg
+lip/GRID/s2/pwip7p.mpg
+lip/GRID/s2/pwip8a.mpg
+lip/GRID/s2/pwixzs.mpg
+lip/GRID/s2/sbaa5p.mpg
+lip/GRID/s2/sbag8s.mpg
+lip/GRID/s2/sban2s.mpg
+lip/GRID/s2/sbba7n.mpg
+lip/GRID/s2/sbba8s.mpg
+lip/GRID/s2/sbbuzs.mpg
+lip/GRID/s2/sbinza.mpg
+lip/GRID/s2/sbwu3n.mpg
+lip/GRID/s2/sgai8a.mpg
+lip/GRID/s2/sgapzs.mpg
+lip/GRID/s2/sgbp4s.mpg
+lip/GRID/s2/sgib7n.mpg
+lip/GRID/s2/sgii4a.mpg
+lip/GRID/s2/sgio5n.mpg
+lip/GRID/s2/sgio6s.mpg
+lip/GRID/s2/sgivzs.mpg
+lip/GRID/s2/sgwd2a.mpg
+lip/GRID/s2/sgwj5p.mpg
+lip/GRID/s2/sgwx3p.mpg
+lip/GRID/s2/srah4s.mpg
+lip/GRID/s2/srau3p.mpg
+lip/GRID/s2/srbb3n.mpg
+lip/GRID/s2/srbb4s.mpg
+lip/GRID/s2/srbb6a.mpg
+lip/GRID/s2/srbh7n.mpg
+lip/GRID/s2/srbu6s.mpg
+lip/GRID/s2/srbu7p.mpg
+lip/GRID/s2/srih2a.mpg
+lip/GRID/s2/srin3n.mpg
+lip/GRID/s2/srin4s.mpg
+lip/GRID/s2/srit8s.mpg
+lip/GRID/s2/srit9p.mpg
+lip/GRID/s2/srwi1n.mpg
+lip/GRID/s2/srwi3p.mpg
+lip/GRID/s2/srwv1p.mpg
+lip/GRID/s2/swai1p.mpg
+lip/GRID/s2/swao5p.mpg
+lip/GRID/s2/swau9p.mpg
+lip/GRID/s2/swbi4s.mpg
+lip/GRID/s2/swbi5p.mpg
+lip/GRID/s2/swib2s.mpg
+lip/GRID/s2/swib3p.mpg
+lip/GRID/s2/swib4a.mpg
+lip/GRID/s2/swih5n.mpg
+lip/GRID/s2/swih7p.mpg
+lip/GRID/s2/swiu5p.mpg
+lip/GRID/s2/swwc3n.mpg
+lip/GRID/s2/swwc4s.mpg
+lip/GRID/s2/swwc6a.mpg
+lip/GRID/s2/swwi7n.mpg
+lip/GRID/s2/swwi9p.mpg
+lip/GRID/s2/swwv5n.mpg
+lip/GRID/s2/swwv8a.mpg
+lip/GRID/s24/bbac9n.mpg
+lip/GRID/s24/bbap8s.mpg
+lip/GRID/s24/bbax1n.mpg
+lip/GRID/s24/bbax2s.mpg
+lip/GRID/s24/bbax4a.mpg
+lip/GRID/s24/bbbj8s.mpg
+lip/GRID/s24/bbbq1n.mpg
+lip/GRID/s24/bbbq2s.mpg
+lip/GRID/s24/bbbx5n.mpg
+lip/GRID/s24/bbbx6s.mpg
+lip/GRID/s24/bbbx7p.mpg
+lip/GRID/s24/bbij1p.mpg
+lip/GRID/s24/bbip5p.mpg
+lip/GRID/s24/bbweza.mpg
+lip/GRID/s24/bbwq6s.mpg
+lip/GRID/s24/bbwq7p.mpg
+lip/GRID/s24/bbwx9n.mpg
+lip/GRID/s24/bgar5n.mpg
+lip/GRID/s24/bgie6a.mpg
+lip/GRID/s24/bgik7n.mpg
+lip/GRID/s24/bgir1n.mpg
+lip/GRID/s24/bgiy5n.mpg
+lip/GRID/s24/bgws6a.mpg
+lip/GRID/s24/bgwz8s.mpg
+lip/GRID/s24/brad5n.mpg
+lip/GRID/s24/brad8a.mpg
+lip/GRID/s24/brakzs.mpg
+lip/GRID/s24/brayza.mpg
+lip/GRID/s24/brbe1p.mpg
+lip/GRID/s24/brbk5p.mpg
+lip/GRID/s24/brbq8s.mpg
+lip/GRID/s24/brip9n.mpg
+lip/GRID/s24/brix4s.mpg
+lip/GRID/s24/brix5p.mpg
+lip/GRID/s24/brwe3n.mpg
+lip/GRID/s24/brwk8s.mpg
+lip/GRID/s24/brwr4a.mpg
+lip/GRID/s24/bwae3p.mpg
+lip/GRID/s24/bwae4a.mpg
+lip/GRID/s24/bwak7p.mpg
+lip/GRID/s24/bwblzs.mpg
+lip/GRID/s24/bwby7n.mpg
+lip/GRID/s24/bwid8s.mpg
+lip/GRID/s24/bwiy1p.mpg
+lip/GRID/s24/bwwe9n.mpg
+lip/GRID/s24/bwwl6a.mpg
+lip/GRID/s24/bwwz2s.mpg
+lip/GRID/s24/bwwz3p.mpg
+lip/GRID/s24/lbab5p.mpg
+lip/GRID/s24/lbab6a.mpg
+lip/GRID/s24/lbau7p.mpg
+lip/GRID/s24/lbau8a.mpg
+lip/GRID/s24/lbbb7n.mpg
+lip/GRID/s24/lbbb9p.mpg
+lip/GRID/s24/lbbcza.mpg
+lip/GRID/s24/lbbi2s.mpg
+lip/GRID/s24/lbbi4a.mpg
+lip/GRID/s24/lbin9p.mpg
+lip/GRID/s24/lbiu2s.mpg
+lip/GRID/s24/lbiu4a.mpg
+lip/GRID/s24/lbwc2s.mpg
+lip/GRID/s24/lbwpzs.mpg
+lip/GRID/s24/lbwv5p.mpg
+lip/GRID/s24/lgaj5n.mpg
+lip/GRID/s24/lgaj6s.mpg
+lip/GRID/s24/lgax3n.mpg
+lip/GRID/s24/lgax4s.mpg
+lip/GRID/s24/lgbd5n.mpg
+lip/GRID/s24/lgij1n.mpg
+lip/GRID/s24/lgij2s.mpg
+lip/GRID/s24/lgix1p.mpg
+lip/GRID/s24/lgwq7n.mpg
+lip/GRID/s24/lrac2a.mpg
+lip/GRID/s24/lrapza.mpg
+lip/GRID/s24/lrav1n.mpg
+lip/GRID/s24/lrav2s.mpg
+lip/GRID/s24/lrav4a.mpg
+lip/GRID/s24/lrii2a.mpg
+lip/GRID/s24/lriizs.mpg
+lip/GRID/s24/lrio6a.mpg
+lip/GRID/s24/lriu8s.mpg
+lip/GRID/s24/lrwc9p.mpg
+lip/GRID/s24/lrwj2s.mpg
+lip/GRID/s24/lrwj4a.mpg
+lip/GRID/s24/lwac7p.mpg
+lip/GRID/s24/lwai9n.mpg
+lip/GRID/s24/lwbp7n.mpg
+lip/GRID/s24/lwic4a.mpg
+lip/GRID/s24/lwii6s.mpg
+lip/GRID/s24/lwwkza.mpg
+lip/GRID/s24/pbag4a.mpg
+lip/GRID/s24/pbatzs.mpg
+lip/GRID/s24/pbba1n.mpg
+lip/GRID/s24/pbbg7p.mpg
+lip/GRID/s24/pbbn1p.mpg
+lip/GRID/s24/pbif8s.mpg
+lip/GRID/s24/pbigza.mpg
+lip/GRID/s24/pbim4a.mpg
+lip/GRID/s24/pbwa5n.mpg
+lip/GRID/s24/pbwa6s.mpg
+lip/GRID/s24/pbwt8s.mpg
+lip/GRID/s24/pgab5n.mpg
+lip/GRID/s24/pgao5p.mpg
+lip/GRID/s24/pgbi4s.mpg
+lip/GRID/s24/pgih6s.mpg
+lip/GRID/s24/pgin9n.mpg
+lip/GRID/s24/pgio1p.mpg
+lip/GRID/s24/pgiu3n.mpg
+lip/GRID/s24/pgiu5p.mpg
+lip/GRID/s24/praa5p.mpg
+lip/GRID/s24/pran3p.mpg
+lip/GRID/s24/prbh4a.mpg
+lip/GRID/s24/prbn6s.mpg
+lip/GRID/s24/prbn7p.mpg
+lip/GRID/s24/prbt9n.mpg
+lip/GRID/s24/pria2a.mpg
+lip/GRID/s24/priazs.mpg
+lip/GRID/s24/prit1n.mpg
+lip/GRID/s24/prit3p.mpg
+lip/GRID/s24/prwn9n.mpg
+lip/GRID/s24/prwo1p.mpg
+lip/GRID/s24/pwan8s.mpg
+lip/GRID/s24/pwau2s.mpg
+lip/GRID/s24/pwau3p.mpg
+lip/GRID/s24/pwbb3n.mpg
+lip/GRID/s24/pwbb4s.mpg
+lip/GRID/s24/pwbb6a.mpg
+lip/GRID/s24/pwbh9p.mpg
+lip/GRID/s24/pwbo1n.mpg
+lip/GRID/s24/pwbo2s.mpg
+lip/GRID/s24/pwia8a.mpg
+lip/GRID/s24/pwig9n.mpg
+lip/GRID/s24/pwiuza.mpg
+lip/GRID/s24/pwwb9p.mpg
+lip/GRID/s24/pwwcza.mpg
+lip/GRID/s24/pwwi3p.mpg
+lip/GRID/s24/pwwi4a.mpg
+lip/GRID/s24/sbar6a.mpg
+lip/GRID/s24/sbay7n.mpg
+lip/GRID/s24/sbay8s.mpg
+lip/GRID/s24/sbay9p.mpg
+lip/GRID/s24/sbbf1p.mpg
+lip/GRID/s24/sbbf2a.mpg
+lip/GRID/s24/sbbl3n.mpg
+lip/GRID/s24/sbbl4s.mpg
+lip/GRID/s24/sbbr8s.mpg
+lip/GRID/s24/sbbz4a.mpg
+lip/GRID/s24/sbie3p.mpg
+lip/GRID/s24/sbiq9n.mpg
+lip/GRID/s24/sbirzs.mpg
+lip/GRID/s24/sbwl7n.mpg
+lip/GRID/s24/sbws3p.mpg
+lip/GRID/s24/sbwz6s.mpg
+lip/GRID/s24/sgaazs.mpg
+lip/GRID/s24/sgat4a.mpg
+lip/GRID/s24/sgbg7n.mpg
+lip/GRID/s24/sgbn2s.mpg
+lip/GRID/s24/sgim5p.mpg
+lip/GRID/s24/sgwuzs.mpg
+lip/GRID/s24/sraf4a.mpg
+lip/GRID/s24/sral7p.mpg
+lip/GRID/s24/sraz3n.mpg
+lip/GRID/s24/srbm1p.mpg
+lip/GRID/s24/srbmzs.mpg
+lip/GRID/s24/srbz9p.mpg
+lip/GRID/s24/srie9p.mpg
+lip/GRID/s24/sriz1p.mpg
+lip/GRID/s24/srwgzs.mpg
+lip/GRID/s24/srwm6a.mpg
+lip/GRID/s24/srws7n.mpg
+lip/GRID/s24/swam4a.mpg
+lip/GRID/s24/swas5n.mpg
+lip/GRID/s24/swbm8a.mpg
+lip/GRID/s24/swbs9n.mpg
+lip/GRID/s24/swil7n.mpg
+lip/GRID/s24/swil9p.mpg
+lip/GRID/s24/swiz7p.mpg
+lip/GRID/s24/swwm9n.mpg
+lip/GRID/s24/swwn2a.mpg
+lip/GRID/s24/swwnzs.mpg
+lip/GRID/s24/swwt3n.mpg
+lip/GRID/s25/bbaxzn.mpg
+lip/GRID/s25/bbbd2n.mpg
+lip/GRID/s25/bbip3s.mpg
+lip/GRID/s25/bbwq6p.mpg
+lip/GRID/s25/bbwy1a.mpg
+lip/GRID/s25/bgae6n.mpg
+lip/GRID/s25/bgar7a.mpg
+lip/GRID/s25/bgay8n.mpg
+lip/GRID/s25/bgbf2p.mpg
+lip/GRID/s25/bgbfzn.mpg
+lip/GRID/s25/bgbl6p.mpg
+lip/GRID/s25/bgbr8n.mpg
+lip/GRID/s25/bgiy4n.mpg
+lip/GRID/s25/bgws3s.mpg
+lip/GRID/s25/bgwz7s.mpg
+lip/GRID/s25/bgwz9a.mpg
+lip/GRID/s25/brad5s.mpg
+lip/GRID/s25/brad6p.mpg
+lip/GRID/s25/braj8n.mpg
+lip/GRID/s25/brakzp.mpg
+lip/GRID/s25/braq5a.mpg
+lip/GRID/s25/brax6n.mpg
+lip/GRID/s25/brax8p.mpg
+lip/GRID/s25/brbezp.mpg
+lip/GRID/s25/brbq8p.mpg
+lip/GRID/s25/brid2p.mpg
+lip/GRID/s25/brij5s.mpg
+lip/GRID/s25/brij6p.mpg
+lip/GRID/s25/brix2n.mpg
+lip/GRID/s25/brix5a.mpg
+lip/GRID/s25/brwe4p.mpg
+lip/GRID/s25/brwe5a.mpg
+lip/GRID/s25/brwk9a.mpg
+lip/GRID/s25/brwrzn.mpg
+lip/GRID/s25/bwak4n.mpg
+lip/GRID/s25/bwak5s.mpg
+lip/GRID/s25/bway2n.mpg
+lip/GRID/s25/bwbe5s.mpg
+lip/GRID/s25/bwbk9s.mpg
+lip/GRID/s25/bwid6n.mpg
+lip/GRID/s25/bwik2p.mpg
+lip/GRID/s25/bwik3a.mpg
+lip/GRID/s25/bwix8n.mpg
+lip/GRID/s25/bwiy1a.mpg
+lip/GRID/s25/bwwe9s.mpg
+lip/GRID/s25/bwwr6n.mpg
+lip/GRID/s25/bwwr8p.mpg
+lip/GRID/s25/bwwr9a.mpg
+lip/GRID/s25/bwwz1s.mpg
+lip/GRID/s25/lbah6n.mpg
+lip/GRID/s25/lbah8p.mpg
+lip/GRID/s25/lbao2p.mpg
+lip/GRID/s25/lbau5s.mpg
+lip/GRID/s25/lbbi1s.mpg
+lip/GRID/s25/lbbi2p.mpg
+lip/GRID/s25/lbbo7a.mpg
+lip/GRID/s25/lbbu8n.mpg
+lip/GRID/s25/lbin9a.mpg
+lip/GRID/s25/lbiu3a.mpg
+lip/GRID/s25/lbwc1s.mpg
+lip/GRID/s25/lbwo8n.mpg
+lip/GRID/s25/lbwo9s.mpg
+lip/GRID/s25/lbwp1a.mpg
+lip/GRID/s25/lbwpzp.mpg
+lip/GRID/s25/lbwv5a.mpg
+lip/GRID/s25/lgap8n.mpg
+lip/GRID/s25/lgaq1a.mpg
+lip/GRID/s25/lgax3s.mpg
+lip/GRID/s25/lgbd7a.mpg
+lip/GRID/s25/lgbq3s.mpg
+lip/GRID/s25/lgbx9a.mpg
+lip/GRID/s25/lgic9a.mpg
+lip/GRID/s25/lgij1s.mpg
+lip/GRID/s25/lgij3a.mpg
+lip/GRID/s25/lgijzn.mpg
+lip/GRID/s25/lgixzp.mpg
+lip/GRID/s25/lgwd9s.mpg
+lip/GRID/s25/lgwe1a.mpg
+lip/GRID/s25/lgwk4p.mpg
+lip/GRID/s25/lgwq6n.mpg
+lip/GRID/s25/lgwq9a.mpg
+lip/GRID/s25/lrai3s.mpg
+lip/GRID/s25/lrbc2n.mpg
+lip/GRID/s25/lrbp2p.mpg
+lip/GRID/s25/lrbv7a.mpg
+lip/GRID/s25/lrib5s.mpg
+lip/GRID/s25/lrib6p.mpg
+lip/GRID/s25/lrio4p.mpg
+lip/GRID/s25/lrwc7s.mpg
+lip/GRID/s25/lrwc8p.mpg
+lip/GRID/s25/lrwj2p.mpg
+lip/GRID/s25/lwac4n.mpg
+lip/GRID/s25/lwac5s.mpg
+lip/GRID/s25/lwac6p.mpg
+lip/GRID/s25/lwac7a.mpg
+lip/GRID/s25/lwbc9s.mpg
+lip/GRID/s25/lwbd1a.mpg
+lip/GRID/s25/lwbj4p.mpg
+lip/GRID/s25/lwbj5a.mpg
+lip/GRID/s25/lwbp6n.mpg
+lip/GRID/s25/lwbx1s.mpg
+lip/GRID/s25/lwiczn.mpg
+lip/GRID/s25/lwii6p.mpg
+lip/GRID/s25/lwiv4p.mpg
+lip/GRID/s25/lwwj6n.mpg
+lip/GRID/s25/lwwq2p.mpg
+lip/GRID/s25/pbag1s.mpg
+lip/GRID/s25/pbas9s.mpg
+lip/GRID/s25/pbat1a.mpg
+lip/GRID/s25/pbatzp.mpg
+lip/GRID/s25/pbba2p.mpg
+lip/GRID/s25/pbba3a.mpg
+lip/GRID/s25/pbbg6p.mpg
+lip/GRID/s25/pbbnzp.mpg
+lip/GRID/s25/pbiz8n.mpg
+lip/GRID/s25/pbwa7a.mpg
+lip/GRID/s25/pbwn2n.mpg
+lip/GRID/s25/pbwn5a.mpg
+lip/GRID/s25/pbwt6n.mpg
+lip/GRID/s25/pgab4n.mpg
+lip/GRID/s25/pgab5s.mpg
+lip/GRID/s25/pgah9s.mpg
+lip/GRID/s25/pgao2n.mpg
+lip/GRID/s25/pgao3s.mpg
+lip/GRID/s25/pgao5a.mpg
+lip/GRID/s25/pgbb9s.mpg
+lip/GRID/s25/pgbi2n.mpg
+lip/GRID/s25/pgbi3s.mpg
+lip/GRID/s25/pgih5s.mpg
+lip/GRID/s25/pgin9s.mpg
+lip/GRID/s25/pgiozp.mpg
+lip/GRID/s25/pgiu2n.mpg
+lip/GRID/s25/pgiu4p.mpg
+lip/GRID/s25/pgwp1s.mpg
+lip/GRID/s25/pgwp2p.mpg
+lip/GRID/s25/pgwp3a.mpg
+lip/GRID/s25/pgwpzn.mpg
+lip/GRID/s25/pgwv5s.mpg
+lip/GRID/s25/praa2n.mpg
+lip/GRID/s25/prag8p.mpg
+lip/GRID/s25/prat7a.mpg
+lip/GRID/s25/prbn7a.mpg
+lip/GRID/s25/priazp.mpg
+lip/GRID/s25/prwb3a.mpg
+lip/GRID/s25/prwu3s.mpg
+lip/GRID/s25/pwab1a.mpg
+lip/GRID/s25/pwah2n.mpg
+lip/GRID/s25/pwah3s.mpg
+lip/GRID/s25/pwan9a.mpg
+lip/GRID/s25/pwau1s.mpg
+lip/GRID/s25/pwbu5s.mpg
+lip/GRID/s25/pwbu6p.mpg
+lip/GRID/s25/pwia6p.mpg
+lip/GRID/s25/pwig8n.mpg
+lip/GRID/s25/pwih1a.mpg
+lip/GRID/s25/pwin3s.mpg
+lip/GRID/s25/pwwi1s.mpg
+lip/GRID/s25/pwwizn.mpg
+lip/GRID/s25/pwwu9s.mpg
+lip/GRID/s25/sbbl2n.mpg
+lip/GRID/s25/sbbl4p.mpg
+lip/GRID/s25/sbbl5a.mpg
+lip/GRID/s25/sbbz1s.mpg
+lip/GRID/s25/sbie3a.mpg
+lip/GRID/s25/sbik5s.mpg
+lip/GRID/s25/sbir1a.mpg
+lip/GRID/s25/sbwl8p.mpg
+lip/GRID/s25/sbws1s.mpg
+lip/GRID/s25/sbwz7a.mpg
+lip/GRID/s25/sgag2n.mpg
+lip/GRID/s25/sgam7s.mpg
+lip/GRID/s25/sgam9a.mpg
+lip/GRID/s25/sgat1s.mpg
+lip/GRID/s25/sgat3a.mpg
+lip/GRID/s25/sgbg9a.mpg
+lip/GRID/s25/sgbn1s.mpg
+lip/GRID/s25/sgbnzn.mpg
+lip/GRID/s25/sgbt7a.mpg
+lip/GRID/s25/sgif8n.mpg
+lip/GRID/s25/sgim5a.mpg
+lip/GRID/s25/sgis6n.mpg
+lip/GRID/s25/sgis7s.mpg
+lip/GRID/s25/sgis9a.mpg
+lip/GRID/s25/sgwh3a.mpg
+lip/GRID/s25/srbs3s.mpg
+lip/GRID/s25/srbs5a.mpg
+lip/GRID/s25/srbz7s.mpg
+lip/GRID/s25/sril3a.mpg
+lip/GRID/s25/srwm5a.mpg
+lip/GRID/s25/srws7s.mpg
+lip/GRID/s25/swaf6n.mpg
+lip/GRID/s25/swam3a.mpg
+lip/GRID/s25/swamzn.mpg
+lip/GRID/s25/swas4n.mpg
+lip/GRID/s25/swas5s.mpg
+lip/GRID/s25/swas6p.mpg
+lip/GRID/s25/swas7a.mpg
+lip/GRID/s25/swbg1s.mpg
+lip/GRID/s25/swbm5s.mpg
+lip/GRID/s25/swbm7a.mpg
+lip/GRID/s25/swil8p.mpg
+lip/GRID/s25/swil9a.mpg
+lip/GRID/s25/swwg5s.mpg
+lip/GRID/s25/swwg7a.mpg
+lip/GRID/s25/swwn1a.mpg
+lip/GRID/s25/swwt2n.mpg
+lip/GRID/s25/swwt3s.mpg
+lip/GRID/s3/bbafzn.mpg
+lip/GRID/s3/bbaz2n.mpg
+lip/GRID/s3/bbaz4p.mpg
+lip/GRID/s3/bbbf4n.mpg
+lip/GRID/s3/bbbf5s.mpg
+lip/GRID/s3/bbbs2n.mpg
+lip/GRID/s3/bbbs3s.mpg
+lip/GRID/s3/bbbs4p.mpg
+lip/GRID/s3/bbie9a.mpg
+lip/GRID/s3/bbil3a.mpg
+lip/GRID/s3/bbiz1a.mpg
+lip/GRID/s3/bbwm5a.mpg
+lip/GRID/s3/bgaa7a.mpg
+lip/GRID/s3/bgag8n.mpg
+lip/GRID/s3/bgan2n.mpg
+lip/GRID/s3/bgan4p.mpg
+lip/GRID/s3/bgat6n.mpg
+lip/GRID/s3/bgat8p.mpg
+lip/GRID/s3/bgba9s.mpg
+lip/GRID/s3/bgbb1a.mpg
+lip/GRID/s3/bgbh2n.mpg
+lip/GRID/s3/bgia1s.mpg
+lip/GRID/s3/bgig7a.mpg
+lip/GRID/s3/bgit5a.mpg
+lip/GRID/s3/bras5s.mpg
+lip/GRID/s3/bras6p.mpg
+lip/GRID/s3/brbm4n.mpg
+lip/GRID/s3/brbs9s.mpg
+lip/GRID/s3/bris1s.mpg
+lip/GRID/s3/briz6p.mpg
+lip/GRID/s3/briz7a.mpg
+lip/GRID/s3/brwa1s.mpg
+lip/GRID/s3/brwazn.mpg
+lip/GRID/s3/brwg5s.mpg
+lip/GRID/s3/brwt5a.mpg
+lip/GRID/s3/bwat3a.mpg
+lip/GRID/s3/bwbn1s.mpg
+lip/GRID/s3/bwbn2p.mpg
+lip/GRID/s3/bwbn3a.mpg
+lip/GRID/s3/bwig1a.mpg
+lip/GRID/s3/bwim5a.mpg
+lip/GRID/s3/bwis7s.mpg
+lip/GRID/s3/bwis8p.mpg
+lip/GRID/s3/bwwh1s.mpg
+lip/GRID/s3/lbad4n.mpg
+lip/GRID/s3/lbad7a.mpg
+lip/GRID/s3/lbaj8n.mpg
+lip/GRID/s3/lbaq3s.mpg
+lip/GRID/s3/lbax6n.mpg
+lip/GRID/s3/lbax7s.mpg
+lip/GRID/s3/lbax8p.mpg
+lip/GRID/s3/lbbk5a.mpg
+lip/GRID/s3/lbbq8p.mpg
+lip/GRID/s3/lbid3a.mpg
+lip/GRID/s3/lbip8n.mpg
+lip/GRID/s3/lbwe3s.mpg
+lip/GRID/s3/lbwk6n.mpg
+lip/GRID/s3/lgal7s.mpg
+lip/GRID/s3/lgas1s.mpg
+lip/GRID/s3/lgas2p.mpg
+lip/GRID/s3/lgaz7a.mpg
+lip/GRID/s3/lgbf7s.mpg
+lip/GRID/s3/lgbs5s.mpg
+lip/GRID/s3/lgif1a.mpg
+lip/GRID/s3/lgil3s.mpg
+lip/GRID/s3/lgwg1s.mpg
+lip/GRID/s3/lgwm6p.mpg
+lip/GRID/s3/lgwm7a.mpg
+lip/GRID/s3/lrae3a.mpg
+lip/GRID/s3/lraezn.mpg
+lip/GRID/s3/lray4p.mpg
+lip/GRID/s3/lrbe7a.mpg
+lip/GRID/s3/lrbk8n.mpg
+lip/GRID/s3/lrbl1a.mpg
+lip/GRID/s3/lrby7s.mpg
+lip/GRID/s3/lrby8p.mpg
+lip/GRID/s3/lrid7s.mpg
+lip/GRID/s3/lrwl3s.mpg
+lip/GRID/s3/lrwr8p.mpg
+lip/GRID/s3/lrwzzn.mpg
+lip/GRID/s3/lwae6n.mpg
+lip/GRID/s3/lwal1s.mpg
+lip/GRID/s3/lwalzn.mpg
+lip/GRID/s3/lway8n.mpg
+lip/GRID/s3/lwbr8n.mpg
+lip/GRID/s3/lwbz4p.mpg
+lip/GRID/s3/lwbz5a.mpg
+lip/GRID/s3/lwie3s.mpg
+lip/GRID/s3/lwiy4n.mpg
+lip/GRID/s3/lwwl8n.mpg
+lip/GRID/s3/lwwm1a.mpg
+lip/GRID/s3/lwws4p.mpg
+lip/GRID/s3/lwws5a.mpg
+lip/GRID/s3/lwwz7s.mpg
+lip/GRID/s3/pbao6n.mpg
+lip/GRID/s3/pbav2p.mpg
+lip/GRID/s3/pbbi7s.mpg
+lip/GRID/s3/pbbi8p.mpg
+lip/GRID/s3/pbbp1s.mpg
+lip/GRID/s3/pbbv4n.mpg
+lip/GRID/s3/pbib4n.mpg
+lip/GRID/s3/pbib5s.mpg
+lip/GRID/s3/pbih8n.mpg
+lip/GRID/s3/pbiizp.mpg
+lip/GRID/s3/pbiu7s.mpg
+lip/GRID/s3/pbiu8p.mpg
+lip/GRID/s3/pbiu9a.mpg
+lip/GRID/s3/pbwc6n.mpg
+lip/GRID/s3/pbwp4n.mpg
+lip/GRID/s3/pbwxzp.mpg
+lip/GRID/s3/pgad9a.mpg
+lip/GRID/s3/pgak2p.mpg
+lip/GRID/s3/pgax9s.mpg
+lip/GRID/s3/pgbezn.mpg
+lip/GRID/s3/pgbk5s.mpg
+lip/GRID/s3/pgbq8n.mpg
+lip/GRID/s3/pgby3s.mpg
+lip/GRID/s3/pgid3s.mpg
+lip/GRID/s3/pgiq3a.mpg
+lip/GRID/s3/pgix6p.mpg
+lip/GRID/s3/pgix7a.mpg
+lip/GRID/s3/pgwe7a.mpg
+lip/GRID/s3/pgwlzp.mpg
+lip/GRID/s3/pgwr5a.mpg
+lip/GRID/s3/pgwy9a.mpg
+lip/GRID/s3/prac4n.mpg
+lip/GRID/s3/prai9s.mpg
+lip/GRID/s3/prap4p.mpg
+lip/GRID/s3/prav7s.mpg
+lip/GRID/s3/prbj3s.mpg
+lip/GRID/s3/pric1s.mpg
+lip/GRID/s3/pric2p.mpg
+lip/GRID/s3/pric3a.mpg
+lip/GRID/s3/prii4n.mpg
+lip/GRID/s3/prio8n.mpg
+lip/GRID/s3/prio9s.mpg
+lip/GRID/s3/priv5a.mpg
+lip/GRID/s3/prwd2n.mpg
+lip/GRID/s3/prwj9a.mpg
+lip/GRID/s3/pwad3a.mpg
+lip/GRID/s3/pwadzn.mpg
+lip/GRID/s3/pwbd7a.mpg
+lip/GRID/s3/pwic6n.mpg
+lip/GRID/s3/pwij2p.mpg
+lip/GRID/s3/pwijzn.mpg
+lip/GRID/s3/pwwk5a.mpg
+lip/GRID/s3/sbaa2n.mpg
+lip/GRID/s3/sbaa3s.mpg
+lip/GRID/s3/sbag7s.mpg
+lip/GRID/s3/sbag8p.mpg
+lip/GRID/s3/sbag9a.mpg
+lip/GRID/s3/sbanzn.mpg
+lip/GRID/s3/sbat5s.mpg
+lip/GRID/s3/sbbt9s.mpg
+lip/GRID/s3/sbig2n.mpg
+lip/GRID/s3/sbig3s.mpg
+lip/GRID/s3/sbig4p.mpg
+lip/GRID/s3/sbim8p.mpg
+lip/GRID/s3/sbit2p.mpg
+lip/GRID/s3/sbit3a.mpg
+lip/GRID/s3/sbwbzn.mpg
+lip/GRID/s3/sbwh4n.mpg
+lip/GRID/s3/sbwu3s.mpg
+lip/GRID/s3/sgac1s.mpg
+lip/GRID/s3/sgai5s.mpg
+lip/GRID/s3/sgav3s.mpg
+lip/GRID/s3/sgav5a.mpg
+lip/GRID/s3/sgbc4n.mpg
+lip/GRID/s3/sgbi9s.mpg
+lip/GRID/s3/sgbp3s.mpg
+lip/GRID/s3/sgbv6n.mpg
+lip/GRID/s3/sgbv7s.mpg
+lip/GRID/s3/sgiizn.mpg
+lip/GRID/s3/sgio5s.mpg
+lip/GRID/s3/sgiu9s.mpg
+lip/GRID/s3/sgwc8n.mpg
+lip/GRID/s3/sraa9s.mpg
+lip/GRID/s3/srab1a.mpg
+lip/GRID/s3/sran7s.mpg
+lip/GRID/s3/srau3a.mpg
+lip/GRID/s3/srbh6n.mpg
+lip/GRID/s3/srbu4n.mpg
+lip/GRID/s3/srbu6p.mpg
+lip/GRID/s3/srit6n.mpg
+lip/GRID/s3/srit9a.mpg
+lip/GRID/s3/srwb6n.mpg
+lip/GRID/s3/srwi3a.mpg
+lip/GRID/s3/srwo6p.mpg
+lip/GRID/s3/srwo7a.mpg
+lip/GRID/s3/srwvzp.mpg
+lip/GRID/s3/swao2n.mpg
+lip/GRID/s3/swao3s.mpg
+lip/GRID/s3/swbvzn.mpg
+lip/GRID/s3/swibzn.mpg
+lip/GRID/s3/swih6p.mpg
+lip/GRID/s3/swio1a.mpg
+lip/GRID/s3/swiozp.mpg
+lip/GRID/s3/swiu4p.mpg
+lip/GRID/s3/swwc2n.mpg
+lip/GRID/s3/swwv4n.mpg
+lip/GRID/s30/bbac3n.mpg
+lip/GRID/s30/bbai9p.mpg
+lip/GRID/s30/bbap3p.mpg
+lip/GRID/s30/bbav6s.mpg
+lip/GRID/s30/bbbc9p.mpg
+lip/GRID/s30/bbbdza.mpg
+lip/GRID/s30/bbbj4a.mpg
+lip/GRID/s30/bbbx1p.mpg
+lip/GRID/s30/bbbxzs.mpg
+lip/GRID/s30/bbic1p.mpg
+lip/GRID/s30/bbiczs.mpg
+lip/GRID/s30/bbio8s.mpg
+lip/GRID/s30/bbio9p.mpg
+lip/GRID/s30/bbiv3p.mpg
+lip/GRID/s30/bbwd4a.mpg
+lip/GRID/s30/bbwp9n.mpg
+lip/GRID/s30/bgay4s.mpg
+lip/GRID/s30/bgay5p.mpg
+lip/GRID/s30/bgbe7p.mpg
+lip/GRID/s30/bgbk9n.mpg
+lip/GRID/s30/bgblzs.mpg
+lip/GRID/s30/bgbr6a.mpg
+lip/GRID/s30/bgid8s.mpg
+lip/GRID/s30/bgiq5n.mpg
+lip/GRID/s30/bgix9n.mpg
+lip/GRID/s30/bgwe9n.mpg
+lip/GRID/s30/bgwl3n.mpg
+lip/GRID/s30/braj6a.mpg
+lip/GRID/s30/brap8s.mpg
+lip/GRID/s30/brbd4s.mpg
+lip/GRID/s30/brbd6a.mpg
+lip/GRID/s30/brbkza.mpg
+lip/GRID/s30/brbx5n.mpg
+lip/GRID/s30/brbx7p.mpg
+lip/GRID/s30/bric6s.mpg
+lip/GRID/s30/brip6a.mpg
+lip/GRID/s30/briv8s.mpg
+lip/GRID/s30/brixza.mpg
+lip/GRID/s30/brwd9p.mpg
+lip/GRID/s30/brwq5n.mpg
+lip/GRID/s30/brwyzs.mpg
+lip/GRID/s30/bwad6s.mpg
+lip/GRID/s30/bwaq3n.mpg
+lip/GRID/s30/bwby1n.mpg
+lip/GRID/s30/bwby4a.mpg
+lip/GRID/s30/bwid3p.mpg
+lip/GRID/s30/bwij7p.mpg
+lip/GRID/s30/bwip9n.mpg
+lip/GRID/s30/bwiq1p.mpg
+lip/GRID/s30/bwix4s.mpg
+lip/GRID/s30/bwwe3n.mpg
+lip/GRID/s30/bwwe5p.mpg
+lip/GRID/s30/bwwe6a.mpg
+lip/GRID/s30/lbah1n.mpg
+lip/GRID/s30/lban7p.mpg
+lip/GRID/s30/lbat9n.mpg
+lip/GRID/s30/lbbb4a.mpg
+lip/GRID/s30/lbbh5n.mpg
+lip/GRID/s30/lbbu6a.mpg
+lip/GRID/s30/lbia3n.mpg
+lip/GRID/s30/lbia5p.mpg
+lip/GRID/s30/lbihza.mpg
+lip/GRID/s30/lbit6s.mpg
+lip/GRID/s30/lbwb6s.mpg
+lip/GRID/s30/lbwi1p.mpg
+lip/GRID/s30/lbwo6a.mpg
+lip/GRID/s30/lgac7p.mpg
+lip/GRID/s30/lgaj2a.mpg
+lip/GRID/s30/lgap3n.mpg
+lip/GRID/s30/lgap4s.mpg
+lip/GRID/s30/lgaxza.mpg
+lip/GRID/s30/lgbdzs.mpg
+lip/GRID/s30/lgbx2s.mpg
+lip/GRID/s30/lgii8a.mpg
+lip/GRID/s30/lgip1p.mpg
+lip/GRID/s30/lgwq3p.mpg
+lip/GRID/s30/lrab3n.mpg
+lip/GRID/s30/lrab6a.mpg
+lip/GRID/s30/lrau6s.mpg
+lip/GRID/s30/lrbb9p.mpg
+lip/GRID/s30/lrbu9n.mpg
+lip/GRID/s30/lria9n.mpg
+lip/GRID/s30/lrin7n.mpg
+lip/GRID/s30/lriu3p.mpg
+lip/GRID/s30/lrwi8a.mpg
+lip/GRID/s30/lrwo9n.mpg
+lip/GRID/s30/lwac1p.mpg
+lip/GRID/s30/lwac2a.mpg
+lip/GRID/s30/lwav4a.mpg
+lip/GRID/s30/lwbc3n.mpg
+lip/GRID/s30/lwbc6a.mpg
+lip/GRID/s30/lwii2a.mpg
+lip/GRID/s30/lwio3n.mpg
+lip/GRID/s30/lwiu9p.mpg
+lip/GRID/s30/lwwc9p.mpg
+lip/GRID/s30/lwwj4a.mpg
+lip/GRID/s30/lwwp6s.mpg
+lip/GRID/s30/pbaf5n.mpg
+lip/GRID/s30/pbamzs.mpg
+lip/GRID/s30/pbbg2a.mpg
+lip/GRID/s30/pbbs9p.mpg
+lip/GRID/s30/pbif1n.mpg
+lip/GRID/s30/pbif4a.mpg
+lip/GRID/s30/pbil8a.mpg
+lip/GRID/s30/pbir9n.mpg
+lip/GRID/s30/pbiz3n.mpg
+lip/GRID/s30/pbwg4s.mpg
+lip/GRID/s30/pgaa9n.mpg
+lip/GRID/s30/pgab2a.mpg
+lip/GRID/s30/pgabzs.mpg
+lip/GRID/s30/pgah5p.mpg
+lip/GRID/s30/pgan8s.mpg
+lip/GRID/s30/pgau1n.mpg
+lip/GRID/s30/pgbb5p.mpg
+lip/GRID/s30/pgbh8s.mpg
+lip/GRID/s30/pgbh9p.mpg
+lip/GRID/s30/pgig9n.mpg
+lip/GRID/s30/pgihzs.mpg
+lip/GRID/s30/pgin4s.mpg
+lip/GRID/s30/pgwi1n.mpg
+lip/GRID/s30/pgwi2s.mpg
+lip/GRID/s30/pgwv1p.mpg
+lip/GRID/s30/praaza.mpg
+lip/GRID/s30/pram8a.mpg
+lip/GRID/s30/prbm9n.mpg
+lip/GRID/s30/prbnzs.mpg
+lip/GRID/s30/prbt4s.mpg
+lip/GRID/s30/prim1n.mpg
+lip/GRID/s30/pris5n.mpg
+lip/GRID/s30/pris8a.mpg
+lip/GRID/s30/prwa6s.mpg
+lip/GRID/s30/prwh2a.mpg
+lip/GRID/s30/prwn4s.mpg
+lip/GRID/s30/prwuza.mpg
+lip/GRID/s30/pwaa3n.mpg
+lip/GRID/s30/pwahza.mpg
+lip/GRID/s30/pwan3p.mpg
+lip/GRID/s30/pwat7p.mpg
+lip/GRID/s30/pwbn8a.mpg
+lip/GRID/s30/pwbuzs.mpg
+lip/GRID/s30/pwia2a.mpg
+lip/GRID/s30/pwig6a.mpg
+lip/GRID/s30/pwinza.mpg
+lip/GRID/s30/pwwh5n.mpg
+lip/GRID/s30/pwwh7p.mpg
+lip/GRID/s30/pwwn9n.mpg
+lip/GRID/s30/pwwu4s.mpg
+lip/GRID/s30/pwwu6a.mpg
+lip/GRID/s30/sbad9n.mpg
+lip/GRID/s30/sbae2a.mpg
+lip/GRID/s30/sbak3n.mpg
+lip/GRID/s30/sbbe4s.mpg
+lip/GRID/s30/sbbe5p.mpg
+lip/GRID/s30/sbbk9p.mpg
+lip/GRID/s30/sbblza.mpg
+lip/GRID/s30/sbid5n.mpg
+lip/GRID/s30/sbik1p.mpg
+lip/GRID/s30/sbix8s.mpg
+lip/GRID/s30/sbwl2s.mpg
+lip/GRID/s30/sbwr7p.mpg
+lip/GRID/s30/sgam1n.mpg
+lip/GRID/s30/sgam4a.mpg
+lip/GRID/s30/sgaz9n.mpg
+lip/GRID/s30/sgbg1n.mpg
+lip/GRID/s30/sgbm7p.mpg
+lip/GRID/s30/sgil8s.mpg
+lip/GRID/s30/sgimza.mpg
+lip/GRID/s30/sgwa2s.mpg
+lip/GRID/s30/sgwnzs.mpg
+lip/GRID/s30/sgwt3n.mpg
+lip/GRID/s30/srae5n.mpg
+lip/GRID/s30/sralzs.mpg
+lip/GRID/s30/srbz4a.mpg
+lip/GRID/s30/srir1p.mpg
+lip/GRID/s30/srirzs.mpg
+lip/GRID/s30/sriy3n.mpg
+lip/GRID/s30/srws1n.mpg
+lip/GRID/s30/srwz5n.mpg
+lip/GRID/s30/swaz5p.mpg
+lip/GRID/s30/swbf8a.mpg
+lip/GRID/s30/swbl9n.mpg
+lip/GRID/s30/swbm1p.mpg
+lip/GRID/s30/swbs5p.mpg
+lip/GRID/s30/swie7n.mpg
+lip/GRID/s30/swie9p.mpg
+lip/GRID/s30/swil4a.mpg
+lip/GRID/s30/swir5n.mpg
+lip/GRID/s30/swwg2a.mpg
+lip/GRID/s31/bbac3s.mpg
+lip/GRID/s31/bbai8p.mpg
+lip/GRID/s31/bbap3a.mpg
+lip/GRID/s31/bbav5s.mpg
+lip/GRID/s31/bbbc9a.mpg
+lip/GRID/s31/bbbxzp.mpg
+lip/GRID/s31/bbib8n.mpg
+lip/GRID/s31/bbiczp.mpg
+lip/GRID/s31/bbii2n.mpg
+lip/GRID/s31/bbii5a.mpg
+lip/GRID/s31/bbio7s.mpg
+lip/GRID/s31/bbwd3a.mpg
+lip/GRID/s31/bbwdzn.mpg
+lip/GRID/s31/bbwj6p.mpg
+lip/GRID/s31/bbwqzp.mpg
+lip/GRID/s31/bbwx4p.mpg
+lip/GRID/s31/bgbe5s.mpg
+lip/GRID/s31/bgbr2n.mpg
+lip/GRID/s31/bgbr4p.mpg
+lip/GRID/s31/bgby7s.mpg
+lip/GRID/s31/bgid7s.mpg
+lip/GRID/s31/bgid9a.mpg
+lip/GRID/s31/bgik3a.mpg
+lip/GRID/s31/bgiq5s.mpg
+lip/GRID/s31/bgix8n.mpg
+lip/GRID/s31/bgwe8n.mpg
+lip/GRID/s31/bgwr9a.mpg
+lip/GRID/s31/brac8n.mpg
+lip/GRID/s31/braj3s.mpg
+lip/GRID/s31/brax2p.mpg
+lip/GRID/s31/brbq1s.mpg
+lip/GRID/s31/bric5s.mpg
+lip/GRID/s31/brwkzn.mpg
+lip/GRID/s31/bwad4n.mpg
+lip/GRID/s31/bwaj9s.mpg
+lip/GRID/s31/bwaq5a.mpg
+lip/GRID/s31/bwax9a.mpg
+lip/GRID/s31/bwbezp.mpg
+lip/GRID/s31/bwbq6n.mpg
+lip/GRID/s31/bwby1s.mpg
+lip/GRID/s31/bwby3a.mpg
+lip/GRID/s31/bwid1s.mpg
+lip/GRID/s31/bwij5s.mpg
+lip/GRID/s31/bwiq1a.mpg
+lip/GRID/s31/bwwe2n.mpg
+lip/GRID/s31/bwwr3a.mpg
+lip/GRID/s31/bwwrzn.mpg
+lip/GRID/s31/lbaa8p.mpg
+lip/GRID/s31/lbau1a.mpg
+lip/GRID/s31/lbbb3a.mpg
+lip/GRID/s31/lbbbzn.mpg
+lip/GRID/s31/lbbozp.mpg
+lip/GRID/s31/lbbu2n.mpg
+lip/GRID/s31/lbig6n.mpg
+lip/GRID/s31/lbig7s.mpg
+lip/GRID/s31/lbin1s.mpg
+lip/GRID/s31/lbit7a.mpg
+lip/GRID/s31/lbwb4n.mpg
+lip/GRID/s31/lbwb5s.mpg
+lip/GRID/s31/lbwh9s.mpg
+lip/GRID/s31/lgac7a.mpg
+lip/GRID/s31/lgai9s.mpg
+lip/GRID/s31/lgap2n.mpg
+lip/GRID/s31/lgbc9s.mpg
+lip/GRID/s31/lgbj3s.mpg
+lip/GRID/s31/lgbj5a.mpg
+lip/GRID/s31/lgbp6n.mpg
+lip/GRID/s31/lgbp8p.mpg
+lip/GRID/s31/lgbx3a.mpg
+lip/GRID/s31/lgic3a.mpg
+lip/GRID/s31/lgiczn.mpg
+lip/GRID/s31/lgio9s.mpg
+lip/GRID/s31/lgip1a.mpg
+lip/GRID/s31/lgiv4p.mpg
+lip/GRID/s31/lgwd4p.mpg
+lip/GRID/s31/lgwd5a.mpg
+lip/GRID/s31/lgwj6n.mpg
+lip/GRID/s31/lgwq1s.mpg
+lip/GRID/s31/lgwq3a.mpg
+lip/GRID/s31/lgwx5s.mpg
+lip/GRID/s31/lrbi2p.mpg
+lip/GRID/s31/lrbizn.mpg
+lip/GRID/s31/lrbu8n.mpg
+lip/GRID/s31/lrbvzp.mpg
+lip/GRID/s31/lrih4p.mpg
+lip/GRID/s31/lrih5a.mpg
+lip/GRID/s31/lrwczn.mpg
+lip/GRID/s31/lrwi6p.mpg
+lip/GRID/s31/lrwo9s.mpg
+lip/GRID/s31/lwai3s.mpg
+lip/GRID/s31/lwai5a.mpg
+lip/GRID/s31/lwib4n.mpg
+lip/GRID/s31/lwio3s.mpg
+lip/GRID/s31/lwwc7s.mpg
+lip/GRID/s31/lwwj3a.mpg
+lip/GRID/s31/lwwv9s.mpg
+lip/GRID/s31/lwwxzp.mpg
+lip/GRID/s31/pbaf6p.mpg
+lip/GRID/s31/pbal8n.mpg
+lip/GRID/s31/pbal9s.mpg
+lip/GRID/s31/pbaz8p.mpg
+lip/GRID/s31/pbbf9s.mpg
+lip/GRID/s31/pbbgzp.mpg
+lip/GRID/s31/pbbm4p.mpg
+lip/GRID/s31/pbbm5a.mpg
+lip/GRID/s31/pbbs9a.mpg
+lip/GRID/s31/pbil4n.mpg
+lip/GRID/s31/pbil5s.mpg
+lip/GRID/s31/pbwg5a.mpg
+lip/GRID/s31/pbwm7s.mpg
+lip/GRID/s31/pgaa8n.mpg
+lip/GRID/s31/pgab1a.mpg
+lip/GRID/s31/pgah2n.mpg
+lip/GRID/s31/pgah4p.mpg
+lip/GRID/s31/pgah5a.mpg
+lip/GRID/s31/pgan6n.mpg
+lip/GRID/s31/pgan8p.mpg
+lip/GRID/s31/pgbh7s.mpg
+lip/GRID/s31/pgbo2p.mpg
+lip/GRID/s31/pgbu4n.mpg
+lip/GRID/s31/pgbu7a.mpg
+lip/GRID/s31/prag3a.mpg
+lip/GRID/s31/pram6p.mpg
+lip/GRID/s31/prba2p.mpg
+lip/GRID/s31/prbazn.mpg
+lip/GRID/s31/prbg7a.mpg
+lip/GRID/s31/prbn1a.mpg
+lip/GRID/s31/prbnzp.mpg
+lip/GRID/s31/prbt3s.mpg
+lip/GRID/s31/prim1s.mpg
+lip/GRID/s31/pris6p.mpg
+lip/GRID/s31/prwa6p.mpg
+lip/GRID/s31/prwh1a.mpg
+lip/GRID/s31/prwt6n.mpg
+lip/GRID/s31/prwt9a.mpg
+lip/GRID/s31/pwba6n.mpg
+lip/GRID/s31/pwbh1s.mpg
+lip/GRID/s31/pwbhzn.mpg
+lip/GRID/s31/pwig4p.mpg
+lip/GRID/s31/pwig5a.mpg
+lip/GRID/s31/pwim9a.mpg
+lip/GRID/s31/pwit2p.mpg
+lip/GRID/s31/pwwh7a.mpg
+lip/GRID/s31/pwwu3s.mpg
+lip/GRID/s31/sbad9s.mpg
+lip/GRID/s31/sbak5a.mpg
+lip/GRID/s31/sbay1s.mpg
+lip/GRID/s31/sbay3a.mpg
+lip/GRID/s31/sbbe2n.mpg
+lip/GRID/s31/sbbk7s.mpg
+lip/GRID/s31/sbbrzn.mpg
+lip/GRID/s31/sbix6n.mpg
+lip/GRID/s31/sbix8p.mpg
+lip/GRID/s31/sbwe8p.mpg
+lip/GRID/s31/sbwlzn.mpg
+lip/GRID/s31/sbwr5s.mpg
+lip/GRID/s31/sgaz9s.mpg
+lip/GRID/s31/sgbg3a.mpg
+lip/GRID/s31/sgbm6p.mpg
+lip/GRID/s31/sgif2n.mpg
+lip/GRID/s31/sgil6n.mpg
+lip/GRID/s31/sgil7s.mpg
+lip/GRID/s31/sgil8p.mpg
+lip/GRID/s31/sgiz5s.mpg
+lip/GRID/s31/sgwa1s.mpg
+lip/GRID/s31/sgwm9s.mpg
+lip/GRID/s31/sray6n.mpg
+lip/GRID/s31/srbl3s.mpg
+lip/GRID/s31/srbr6n.mpg
+lip/GRID/s31/srbr8p.mpg
+lip/GRID/s31/srbr9a.mpg
+lip/GRID/s31/srbz1s.mpg
+lip/GRID/s31/srbz2p.mpg
+lip/GRID/s31/srbz3a.mpg
+lip/GRID/s31/srbzzn.mpg
+lip/GRID/s31/srik5s.mpg
+lip/GRID/s31/sriy3s.mpg
+lip/GRID/s31/sriy5a.mpg
+lip/GRID/s31/srwl6n.mpg
+lip/GRID/s31/srwl7s.mpg
+lip/GRID/s31/swaf1s.mpg
+lip/GRID/s31/swaf2p.mpg
+lip/GRID/s31/swal4n.mpg
+lip/GRID/s31/swal5s.mpg
+lip/GRID/s31/swar8n.mpg
+lip/GRID/s31/swbl9s.mpg
+lip/GRID/s31/swbs4p.mpg
+lip/GRID/s31/swbs5a.mpg
+lip/GRID/s31/swbz9a.mpg
+lip/GRID/s31/swie6n.mpg
+lip/GRID/s31/swie8p.mpg
+lip/GRID/s31/swil1s.mpg
+lip/GRID/s31/swir7a.mpg
+lip/GRID/s31/swiy9s.mpg
+lip/GRID/s31/swwf9s.mpg
+lip/GRID/s4/bbal4s.mpg
+lip/GRID/s4/bbar7n.mpg
+lip/GRID/s4/bbar8s.mpg
+lip/GRID/s4/bbbf4s.mpg
+lip/GRID/s4/bbbz5n.mpg
+lip/GRID/s4/bbbz7p.mpg
+lip/GRID/s4/bbizza.mpg
+lip/GRID/s4/bbwf9p.mpg
+lip/GRID/s4/bbwm1n.mpg
+lip/GRID/s4/bgaa4s.mpg
+lip/GRID/s4/bgaa5p.mpg
+lip/GRID/s4/bgan4a.mpg
+lip/GRID/s4/bgat5n.mpg
+lip/GRID/s4/bgba7n.mpg
+lip/GRID/s4/bgbh1n.mpg
+lip/GRID/s4/bgbu2a.mpg
+lip/GRID/s4/bgig3n.mpg
+lip/GRID/s4/bgig4s.mpg
+lip/GRID/s4/bgim9p.mpg
+lip/GRID/s4/bginza.mpg
+lip/GRID/s4/bgit3p.mpg
+lip/GRID/s4/bgit4a.mpg
+lip/GRID/s4/bgwb1n.mpg
+lip/GRID/s4/bgwb3p.mpg
+lip/GRID/s4/bgwh5n.mpg
+lip/GRID/s4/bgwh6s.mpg
+lip/GRID/s4/bgwn9n.mpg
+lip/GRID/s4/bgwu3n.mpg
+lip/GRID/s4/bgwu6a.mpg
+lip/GRID/s4/braf6s.mpg
+lip/GRID/s4/braf7p.mpg
+lip/GRID/s4/braf8a.mpg
+lip/GRID/s4/bram1p.mpg
+lip/GRID/s4/bras5p.mpg
+lip/GRID/s4/braz9p.mpg
+lip/GRID/s4/brbg1p.mpg
+lip/GRID/s4/brbs7n.mpg
+lip/GRID/s4/brbs8s.mpg
+lip/GRID/s4/brbtza.mpg
+lip/GRID/s4/brif4a.mpg
+lip/GRID/s4/bril6s.mpg
+lip/GRID/s4/bris1p.mpg
+lip/GRID/s4/briz4s.mpg
+lip/GRID/s4/brwa1p.mpg
+lip/GRID/s4/brwg5p.mpg
+lip/GRID/s4/brwm8s.mpg
+lip/GRID/s4/brwnza.mpg
+lip/GRID/s4/brwt4a.mpg
+lip/GRID/s4/bwam5n.mpg
+lip/GRID/s4/bwas9n.mpg
+lip/GRID/s4/bwat1p.mpg
+lip/GRID/s4/bwba1n.mpg
+lip/GRID/s4/bwba3p.mpg
+lip/GRID/s4/bwbm9n.mpg
+lip/GRID/s4/bwbn1p.mpg
+lip/GRID/s4/bwbt4s.mpg
+lip/GRID/s4/bwigza.mpg
+lip/GRID/s4/bwis6s.mpg
+lip/GRID/s4/bwiz9n.mpg
+lip/GRID/s4/bwwa5n.mpg
+lip/GRID/s4/bwwn5p.mpg
+lip/GRID/s4/lbad3n.mpg
+lip/GRID/s4/lbad4s.mpg
+lip/GRID/s4/lbakza.mpg
+lip/GRID/s4/lbaq2s.mpg
+lip/GRID/s4/lbaq3p.mpg
+lip/GRID/s4/lbaq4a.mpg
+lip/GRID/s4/lbax5n.mpg
+lip/GRID/s4/lbbk3p.mpg
+lip/GRID/s4/lbbq7p.mpg
+lip/GRID/s4/lbbq8a.mpg
+lip/GRID/s4/lbid1p.mpg
+lip/GRID/s4/lbidzs.mpg
+lip/GRID/s4/lbiqza.mpg
+lip/GRID/s4/lbix1n.mpg
+lip/GRID/s4/lbwk8a.mpg
+lip/GRID/s4/lbwy4s.mpg
+lip/GRID/s4/lgaf1n.mpg
+lip/GRID/s4/lgal5n.mpg
+lip/GRID/s4/lgas1p.mpg
+lip/GRID/s4/lgaz4s.mpg
+lip/GRID/s4/lgaz5p.mpg
+lip/GRID/s4/lgaz6a.mpg
+lip/GRID/s4/lgbl9n.mpg
+lip/GRID/s4/lgbmzs.mpg
+lip/GRID/s4/lgbs4s.mpg
+lip/GRID/s4/lgil4a.mpg
+lip/GRID/s4/lgir6s.mpg
+lip/GRID/s4/lgir7p.mpg
+lip/GRID/s4/lgir8a.mpg
+lip/GRID/s4/lgiz1p.mpg
+lip/GRID/s4/lgiz2a.mpg
+lip/GRID/s4/lgwm4s.mpg
+lip/GRID/s4/lray3p.mpg
+lip/GRID/s4/lrbe4s.mpg
+lip/GRID/s4/lrbe6a.mpg
+lip/GRID/s4/lrbk7n.mpg
+lip/GRID/s4/lrbk8s.mpg
+lip/GRID/s4/lrblza.mpg
+lip/GRID/s4/lriq3n.mpg
+lip/GRID/s4/lrwl3p.mpg
+lip/GRID/s4/lrwzzs.mpg
+lip/GRID/s4/lwae5n.mpg
+lip/GRID/s4/lwal1p.mpg
+lip/GRID/s4/lwbr7n.mpg
+lip/GRID/s4/lwbsza.mpg
+lip/GRID/s4/lwbz1n.mpg
+lip/GRID/s4/lwie2s.mpg
+lip/GRID/s4/lwik5n.mpg
+lip/GRID/s4/lwiy5p.mpg
+lip/GRID/s4/lwwl7n.mpg
+lip/GRID/s4/lwwz7p.mpg
+lip/GRID/s4/pbai2s.mpg
+lip/GRID/s4/pbao5n.mpg
+lip/GRID/s4/pbbc1n.mpg
+lip/GRID/s4/pbbc3p.mpg
+lip/GRID/s4/pbbi5n.mpg
+lip/GRID/s4/pbbv3n.mpg
+lip/GRID/s4/pbio3p.mpg
+lip/GRID/s4/pbio4a.mpg
+lip/GRID/s4/pbiu7p.mpg
+lip/GRID/s4/pbwj1p.mpg
+lip/GRID/s4/pbwp4s.mpg
+lip/GRID/s4/pbwp5p.mpg
+lip/GRID/s4/pbwv7n.mpg
+lip/GRID/s4/pbwxza.mpg
+lip/GRID/s4/pgad7p.mpg
+lip/GRID/s4/pgak1p.mpg
+lip/GRID/s4/pgak2a.mpg
+lip/GRID/s4/pgaq3n.mpg
+lip/GRID/s4/pgayza.mpg
+lip/GRID/s4/pgbd9n.mpg
+lip/GRID/s4/pgbe1p.mpg
+lip/GRID/s4/pgbq7n.mpg
+lip/GRID/s4/pgbq9p.mpg
+lip/GRID/s4/pgid2s.mpg
+lip/GRID/s4/pgij6s.mpg
+lip/GRID/s4/pgiq1p.mpg
+lip/GRID/s4/pgwk9p.mpg
+lip/GRID/s4/pgwr1n.mpg
+lip/GRID/s4/pgwr3p.mpg
+lip/GRID/s4/prap4a.mpg
+lip/GRID/s4/prav8a.mpg
+lip/GRID/s4/prbc8s.mpg
+lip/GRID/s4/prii5p.mpg
+lip/GRID/s4/priv2s.mpg
+lip/GRID/s4/prwq1p.mpg
+lip/GRID/s4/pwax1n.mpg
+lip/GRID/s4/pwbx7p.mpg
+lip/GRID/s4/pwbx8a.mpg
+lip/GRID/s4/pwic7p.mpg
+lip/GRID/s4/pwip4s.mpg
+lip/GRID/s4/pwiv9p.mpg
+lip/GRID/s4/pwwk2s.mpg
+lip/GRID/s4/pwwk4a.mpg
+lip/GRID/s4/pwwq6s.mpg
+lip/GRID/s4/pwwy1p.mpg
+lip/GRID/s4/pwwyzs.mpg
+lip/GRID/s4/sbaa2s.mpg
+lip/GRID/s4/sbag6s.mpg
+lip/GRID/s4/sbag8a.mpg
+lip/GRID/s4/sban2a.mpg
+lip/GRID/s4/sbat3n.mpg
+lip/GRID/s4/sbat4s.mpg
+lip/GRID/s4/sbat5p.mpg
+lip/GRID/s4/sbba6s.mpg
+lip/GRID/s4/sbba8a.mpg
+lip/GRID/s4/sbbh1p.mpg
+lip/GRID/s4/sbbhzs.mpg
+lip/GRID/s4/sbbn5p.mpg
+lip/GRID/s4/sbbuza.mpg
+lip/GRID/s4/sbiaza.mpg
+lip/GRID/s4/sbig2s.mpg
+lip/GRID/s4/sbis9n.mpg
+lip/GRID/s4/sbit1p.mpg
+lip/GRID/s4/sbitzs.mpg
+lip/GRID/s4/sbwb1p.mpg
+lip/GRID/s4/sbwh4s.mpg
+lip/GRID/s4/sbwn7n.mpg
+lip/GRID/s4/sgab9n.mpg
+lip/GRID/s4/sgaczs.mpg
+lip/GRID/s4/sgai6a.mpg
+lip/GRID/s4/sgao7n.mpg
+lip/GRID/s4/sgav4a.mpg
+lip/GRID/s4/sgbc4s.mpg
+lip/GRID/s4/sgbp1n.mpg
+lip/GRID/s4/sgbp2s.mpg
+lip/GRID/s4/sgbp4a.mpg
+lip/GRID/s4/sgib6s.mpg
+lip/GRID/s4/sgib8a.mpg
+lip/GRID/s4/sgiu7n.mpg
+lip/GRID/s4/sgiu8s.mpg
+lip/GRID/s4/sgwc7n.mpg
+lip/GRID/s4/sgwp8a.mpg
+lip/GRID/s4/sgwx1p.mpg
+lip/GRID/s4/sran5n.mpg
+lip/GRID/s4/sran7p.mpg
+lip/GRID/s4/srau2a.mpg
+lip/GRID/s4/srbb1n.mpg
+lip/GRID/s4/srbb2s.mpg
+lip/GRID/s4/srbn9n.mpg
+lip/GRID/s4/srbo2a.mpg
+lip/GRID/s4/srbu5p.mpg
+lip/GRID/s4/srig7n.mpg
+lip/GRID/s4/srin2s.mpg
+lip/GRID/s4/srit7p.mpg
+lip/GRID/s4/srit8a.mpg
+lip/GRID/s4/srwh9n.mpg
+lip/GRID/s4/srwi1p.mpg
+lip/GRID/s4/srwizs.mpg
+lip/GRID/s4/srwo3n.mpg
+lip/GRID/s4/swab4s.mpg
+lip/GRID/s4/swbi3p.mpg
+lip/GRID/s4/swbv2a.mpg
+lip/GRID/s4/swbvzs.mpg
+lip/GRID/s4/swia9n.mpg
+lip/GRID/s4/swih3n.mpg
+lip/GRID/s4/swin8s.mpg
+lip/GRID/s7/bbar4n.mpg
+lip/GRID/s7/bbar7a.mpg
+lip/GRID/s7/bbazzp.mpg
+lip/GRID/s7/bbbf3a.mpg
+lip/GRID/s7/bbbfzn.mpg
+lip/GRID/s7/bbbl6p.mpg
+lip/GRID/s7/bbbr9s.mpg
+lip/GRID/s7/bbbz3s.mpg
+lip/GRID/s7/bbik7s.mpg
+lip/GRID/s7/bbirzn.mpg
+lip/GRID/s7/bbwl9s.mpg
+lip/GRID/s7/bbws2n.mpg
+lip/GRID/s7/bbws4p.mpg
+lip/GRID/s7/bbws5a.mpg
+lip/GRID/s7/bgaa2p.mpg
+lip/GRID/s7/bgaa3a.mpg
+lip/GRID/s7/bgat4p.mpg
+lip/GRID/s7/bgat5a.mpg
+lip/GRID/s7/bgba7a.mpg
+lip/GRID/s7/bgbn4p.mpg
+lip/GRID/s7/bgbt9a.mpg
+lip/GRID/s7/bgim4n.mpg
+lip/GRID/s7/bgim5s.mpg
+lip/GRID/s7/bgim7a.mpg
+lip/GRID/s7/bgit1a.mpg
+lip/GRID/s7/bgitzp.mpg
+lip/GRID/s7/bgwb1a.mpg
+lip/GRID/s7/bgwbzp.mpg
+lip/GRID/s7/bral6n.mpg
+lip/GRID/s7/bral9a.mpg
+lip/GRID/s7/bras1s.mpg
+lip/GRID/s7/bras2p.mpg
+lip/GRID/s7/bras3a.mpg
+lip/GRID/s7/braz7a.mpg
+lip/GRID/s7/brbm1s.mpg
+lip/GRID/s7/brizzn.mpg
+lip/GRID/s7/brwm5s.mpg
+lip/GRID/s7/bwbazp.mpg
+lip/GRID/s7/bwim1a.mpg
+lip/GRID/s7/bwwa3s.mpg
+lip/GRID/s7/bwwn2p.mpg
+lip/GRID/s7/bwwn3a.mpg
+lip/GRID/s7/lbap9s.mpg
+lip/GRID/s7/lbaq1a.mpg
+lip/GRID/s7/lbaqzp.mpg
+lip/GRID/s7/lbax4p.mpg
+lip/GRID/s7/lbbd4n.mpg
+lip/GRID/s7/lbbj9s.mpg
+lip/GRID/s7/lbbq3s.mpg
+lip/GRID/s7/lbbx7s.mpg
+lip/GRID/s7/lbbx8p.mpg
+lip/GRID/s7/lbijzn.mpg
+lip/GRID/s7/lbip6p.mpg
+lip/GRID/s7/lbip7a.mpg
+lip/GRID/s7/lbix1a.mpg
+lip/GRID/s7/lbwk3s.mpg
+lip/GRID/s7/lbwy2p.mpg
+lip/GRID/s7/lgae9s.mpg
+lip/GRID/s7/lgar6n.mpg
+lip/GRID/s7/lgbf3s.mpg
+lip/GRID/s7/lgbs1s.mpg
+lip/GRID/s7/lgbszn.mpg
+lip/GRID/s7/lgbz5s.mpg
+lip/GRID/s7/lgbz7a.mpg
+lip/GRID/s7/lgie5s.mpg
+lip/GRID/s7/lgir3s.mpg
+lip/GRID/s7/lrad8p.mpg
+lip/GRID/s7/lrak2p.mpg
+lip/GRID/s7/lrakzn.mpg
+lip/GRID/s7/lraq4n.mpg
+lip/GRID/s7/lraq5s.mpg
+lip/GRID/s7/lraq7a.mpg
+lip/GRID/s7/lrax8n.mpg
+lip/GRID/s7/lrax9s.mpg
+lip/GRID/s7/lrid3s.mpg
+lip/GRID/s7/lrij7s.mpg
+lip/GRID/s7/lrwk9s.mpg
+lip/GRID/s7/lwae4p.mpg
+lip/GRID/s7/lwak7s.mpg
+lip/GRID/s7/lwak9a.mpg
+lip/GRID/s7/lwar1s.mpg
+lip/GRID/s7/lwar2p.mpg
+lip/GRID/s7/lway6p.mpg
+lip/GRID/s7/lway7a.mpg
+lip/GRID/s7/lwbe6n.mpg
+lip/GRID/s7/lwbr6p.mpg
+lip/GRID/s7/lwid8n.mpg
+lip/GRID/s7/lwie1a.mpg
+lip/GRID/s7/lwiezp.mpg
+lip/GRID/s7/lwik3s.mpg
+lip/GRID/s7/lwiq7s.mpg
+lip/GRID/s7/lwwfzn.mpg
+lip/GRID/s7/lwwz2n.mpg
+lip/GRID/s7/lwwz3s.mpg
+lip/GRID/s7/pbab4n.mpg
+lip/GRID/s7/pbab7a.mpg
+lip/GRID/s7/pbai1a.mpg
+lip/GRID/s7/pbaizp.mpg
+lip/GRID/s7/pbao2n.mpg
+lip/GRID/s7/pbao3s.mpg
+lip/GRID/s7/pbao5a.mpg
+lip/GRID/s7/pbbb8n.mpg
+lip/GRID/s7/pbbczp.mpg
+lip/GRID/s7/pbbi3s.mpg
+lip/GRID/s7/pbbo8p.mpg
+lip/GRID/s7/pbbv1s.mpg
+lip/GRID/s7/pbibzn.mpg
+lip/GRID/s7/pbwc2n.mpg
+lip/GRID/s7/pbwp3a.mpg
+lip/GRID/s7/pbwv6p.mpg
+lip/GRID/s7/pbwv7a.mpg
+lip/GRID/s7/pgaj6n.mpg
+lip/GRID/s7/pgaj7s.mpg
+lip/GRID/s7/pgaqzn.mpg
+lip/GRID/s7/pgbd7s.mpg
+lip/GRID/s7/pgbk1s.mpg
+lip/GRID/s7/pgbkzn.mpg
+lip/GRID/s7/pgbq6p.mpg
+lip/GRID/s7/pgbq7a.mpg
+lip/GRID/s7/pgbx9s.mpg
+lip/GRID/s7/pgid1a.mpg
+lip/GRID/s7/pgij2n.mpg
+lip/GRID/s7/pgip8p.mpg
+lip/GRID/s7/pgwk4n.mpg
+lip/GRID/s7/pgwk5s.mpg
+lip/GRID/s7/pgwy5a.mpg
+lip/GRID/s7/prav2n.mpg
+lip/GRID/s7/prav3s.mpg
+lip/GRID/s7/prav4p.mpg
+lip/GRID/s7/prbc4n.mpg
+lip/GRID/s7/prbc6p.mpg
+lip/GRID/s7/prbc7a.mpg
+lip/GRID/s7/prbv8p.mpg
+lip/GRID/s7/prib8p.mpg
+lip/GRID/s7/prwc9s.mpg
+lip/GRID/s7/prwj5a.mpg
+lip/GRID/s7/prwxzn.mpg
+lip/GRID/s7/pwaj3a.mpg
+lip/GRID/s7/pwajzn.mpg
+lip/GRID/s7/pwax1a.mpg
+lip/GRID/s7/pwbj4n.mpg
+lip/GRID/s7/pwbj7a.mpg
+lip/GRID/s7/pwbx2n.mpg
+lip/GRID/s7/pwbx3s.mpg
+lip/GRID/s7/pwbx4p.mpg
+lip/GRID/s7/pwic4p.mpg
+lip/GRID/s7/pwip2p.mpg
+lip/GRID/s7/pwipzn.mpg
+lip/GRID/s7/pwwd5s.mpg
+lip/GRID/s7/pwwd7a.mpg
+lip/GRID/s7/pwwx7s.mpg
+lip/GRID/s7/sbam9a.mpg
+lip/GRID/s7/sbat2p.mpg
+lip/GRID/s7/sbba4p.mpg
+lip/GRID/s7/sbbt5s.mpg
+lip/GRID/s7/sbbt7a.mpg
+lip/GRID/s7/sbif9s.mpg
+lip/GRID/s7/sbig1a.mpg
+lip/GRID/s7/sbis9a.mpg
+lip/GRID/s7/sbwa6n.mpg
+lip/GRID/s7/sbwh1s.mpg
+lip/GRID/s7/sbwh2p.mpg
+lip/GRID/s7/sbwh3a.mpg
+lip/GRID/s7/sbwhzn.mpg
+lip/GRID/s7/sbwuzp.mpg
+lip/GRID/s7/sgai1s.mpg
+lip/GRID/s7/sgai2p.mpg
+lip/GRID/s7/sgaizn.mpg
+lip/GRID/s7/sgau9s.mpg
+lip/GRID/s7/sgbo9s.mpg
+lip/GRID/s7/sgih8p.mpg
+lip/GRID/s7/sgiozn.mpg
+lip/GRID/s7/sgiu5s.mpg
+lip/GRID/s7/sgwc6p.mpg
+lip/GRID/s7/sgwc7a.mpg
+lip/GRID/s7/sgwi8n.mpg
+lip/GRID/s7/sgwjzp.mpg
+lip/GRID/s7/sgwv8p.mpg
+lip/GRID/s7/srahzp.mpg
+lip/GRID/s7/sran2n.mpg
+lip/GRID/s7/srat6n.mpg
+lip/GRID/s7/srbh2n.mpg
+lip/GRID/s7/sria1s.mpg
+lip/GRID/s7/sria2p.mpg
+lip/GRID/s7/srig4n.mpg
+lip/GRID/s7/srit3s.mpg
+lip/GRID/s7/srwb3s.mpg
+lip/GRID/s7/srwozn.mpg
+lip/GRID/s7/srwu4n.mpg
+lip/GRID/s7/swab2p.mpg
+lip/GRID/s7/swabzn.mpg
+lip/GRID/s7/swah4n.mpg
+lip/GRID/s7/swau3s.mpg
+lip/GRID/s7/swbi1a.mpg
+lip/GRID/s7/swbo4p.mpg
+lip/GRID/s7/swbu7s.mpg
+lip/GRID/s7/swia6n.mpg
+lip/GRID/s7/swih3a.mpg
+lip/GRID/s7/swihzn.mpg
+lip/GRID/s7/swin4n.mpg
+lip/GRID/s7/swit8n.mpg
+lip/GRID/s7/swwb9s.mpg
+lip/GRID/s7/swwi4p.mpg
+lip/GRID/s7/swwv1s.mpg
+lip/GRID/s8/bbal2a.mpg
+lip/GRID/s8/bbar5p.mpg
+lip/GRID/s8/bbay7n.mpg
+lip/GRID/s8/bbay8s.mpg
+lip/GRID/s8/bbazza.mpg
+lip/GRID/s8/bbbe9n.mpg
+lip/GRID/s8/bbbl3n.mpg
+lip/GRID/s8/bbbr8s.mpg
+lip/GRID/s8/bbbz2s.mpg
+lip/GRID/s8/bbbz3p.mpg
+lip/GRID/s8/bbik6s.mpg
+lip/GRID/s8/bbir2a.mpg
+lip/GRID/s8/bbwf3n.mpg
+lip/GRID/s8/bbwmza.mpg
+lip/GRID/s8/bbwz6s.mpg
+lip/GRID/s8/bgaa2a.mpg
+lip/GRID/s8/bgag5p.mpg
+lip/GRID/s8/bgam7n.mpg
+lip/GRID/s8/bgba3n.mpg
+lip/GRID/s8/bgbg7n.mpg
+lip/GRID/s8/bgbg8s.mpg
+lip/GRID/s8/bgbn4a.mpg
+lip/GRID/s8/bgbt5n.mpg
+lip/GRID/s8/bgbt6s.mpg
+lip/GRID/s8/bgig2a.mpg
+lip/GRID/s8/bgitza.mpg
+lip/GRID/s8/bgwh1n.mpg
+lip/GRID/s8/bgwh3p.mpg
+lip/GRID/s8/bgwh4a.mpg
+lip/GRID/s8/bgwn8a.mpg
+lip/GRID/s8/bgwu1p.mpg
+lip/GRID/s8/bral5n.mpg
+lip/GRID/s8/braz4s.mpg
+lip/GRID/s8/brbf5n.mpg
+lip/GRID/s8/brbf6s.mpg
+lip/GRID/s8/brbmzs.mpg
+lip/GRID/s8/brbz9p.mpg
+lip/GRID/s8/bril1n.mpg
+lip/GRID/s8/bril2s.mpg
+lip/GRID/s8/bril3p.mpg
+lip/GRID/s8/briz1p.mpg
+lip/GRID/s8/brwg2a.mpg
+lip/GRID/s8/brwm5p.mpg
+lip/GRID/s8/brws8s.mpg
+lip/GRID/s8/brws9p.mpg
+lip/GRID/s8/bwam2s.mpg
+lip/GRID/s8/bwas5n.mpg
+lip/GRID/s8/bwbm8a.mpg
+lip/GRID/s8/bwbt1p.mpg
+lip/GRID/s8/bwbt2a.mpg
+lip/GRID/s8/bwif5p.mpg
+lip/GRID/s8/bwis3p.mpg
+lip/GRID/s8/bwiz6s.mpg
+lip/GRID/s8/bwwg6s.mpg
+lip/GRID/s8/bwwn1p.mpg
+lip/GRID/s8/lbac9n.mpg
+lip/GRID/s8/lbad2a.mpg
+lip/GRID/s8/lbaj3n.mpg
+lip/GRID/s8/lbaqza.mpg
+lip/GRID/s8/lbax2s.mpg
+lip/GRID/s8/lbax4a.mpg
+lip/GRID/s8/lbbq3p.mpg
+lip/GRID/s8/lbbx6s.mpg
+lip/GRID/s8/lbic6s.mpg
+lip/GRID/s8/lbip3n.mpg
+lip/GRID/s8/lbwd9p.mpg
+lip/GRID/s8/lbwq6s.mpg
+lip/GRID/s8/lbwq7p.mpg
+lip/GRID/s8/lbwq8a.mpg
+lip/GRID/s8/lgae8s.mpg
+lip/GRID/s8/lgbf1n.mpg
+lip/GRID/s8/lgbz4s.mpg
+lip/GRID/s8/lgbz6a.mpg
+lip/GRID/s8/lgie3n.mpg
+lip/GRID/s8/lgie6a.mpg
+lip/GRID/s8/lgik7n.mpg
+lip/GRID/s8/lgilza.mpg
+lip/GRID/s8/lgir1n.mpg
+lip/GRID/s8/lgir2s.mpg
+lip/GRID/s8/lgiy5n.mpg
+lip/GRID/s8/lgwl9n.mpg
+lip/GRID/s8/lraj9n.mpg
+lip/GRID/s8/lrak1p.mpg
+lip/GRID/s8/lrbe2a.mpg
+lip/GRID/s8/lrbk5p.mpg
+lip/GRID/s8/lrbk6a.mpg
+lip/GRID/s8/lrbq7n.mpg
+lip/GRID/s8/lrby2s.mpg
+lip/GRID/s8/lrid1n.mpg
+lip/GRID/s8/lrij5n.mpg
+lip/GRID/s8/lrij6s.mpg
+lip/GRID/s8/lrwk9p.mpg
+lip/GRID/s8/lwae4a.mpg
+lip/GRID/s8/lwaq9n.mpg
+lip/GRID/s8/lwarzs.mpg
+lip/GRID/s8/lway4s.mpg
+lip/GRID/s8/lwbe7p.mpg
+lip/GRID/s8/lwby7n.mpg
+lip/GRID/s8/lwby8s.mpg
+lip/GRID/s8/lwid8s.mpg
+lip/GRID/s8/lwid9p.mpg
+lip/GRID/s8/lwik2s.mpg
+lip/GRID/s8/lwiyzs.mpg
+lip/GRID/s8/lwwf2a.mpg
+lip/GRID/s8/lwwl6a.mpg
+lip/GRID/s8/lwwz1n.mpg
+lip/GRID/s8/lwwz3p.mpg
+lip/GRID/s8/pbah7n.mpg
+lip/GRID/s8/pbbb7n.mpg
+lip/GRID/s8/pbbi1n.mpg
+lip/GRID/s8/pbbo6s.mpg
+lip/GRID/s8/pbbo7p.mpg
+lip/GRID/s8/pbia9n.mpg
+lip/GRID/s8/pbib1p.mpg
+lip/GRID/s8/pbib2a.mpg
+lip/GRID/s8/pbih5p.mpg
+lip/GRID/s8/pbin7n.mpg
+lip/GRID/s8/pbwc4a.mpg
+lip/GRID/s8/pbwi5n.mpg
+lip/GRID/s8/pbwi8a.mpg
+lip/GRID/s8/pbwv4s.mpg
+lip/GRID/s8/pbwv5p.mpg
+lip/GRID/s8/pgaj7p.mpg
+lip/GRID/s8/pgax6a.mpg
+lip/GRID/s8/pgbk1p.mpg
+lip/GRID/s8/pgbq5p.mpg
+lip/GRID/s8/pgbx8s.mpg
+lip/GRID/s8/pgidza.mpg
+lip/GRID/s8/pgij3p.mpg
+lip/GRID/s8/pgip8a.mpg
+lip/GRID/s8/pgixzs.mpg
+lip/GRID/s8/pgwe1p.mpg
+lip/GRID/s8/pgwk3n.mpg
+lip/GRID/s8/prbjza.mpg
+lip/GRID/s8/prbp1n.mpg
+lip/GRID/s8/prbv5n.mpg
+lip/GRID/s8/prii1p.mpg
+lip/GRID/s8/prio4s.mpg
+lip/GRID/s8/prio5p.mpg
+lip/GRID/s8/prwc7n.mpg
+lip/GRID/s8/prwc8s.mpg
+lip/GRID/s8/prwc9p.mpg
+lip/GRID/s8/prwp6s.mpg
+lip/GRID/s8/pwac5n.mpg
+lip/GRID/s8/pwac8a.mpg
+lip/GRID/s8/pwap6a.mpg
+lip/GRID/s8/pwav8s.mpg
+lip/GRID/s8/pwav9p.mpg
+lip/GRID/s8/pwbc9n.mpg
+lip/GRID/s8/pwbj5p.mpg
+lip/GRID/s8/pwic2s.mpg
+lip/GRID/s8/pwii6s.mpg
+lip/GRID/s8/pwii7p.mpg
+lip/GRID/s8/pwio9n.mpg
+lip/GRID/s8/pwiv3n.mpg
+lip/GRID/s8/pwwj7n.mpg
+lip/GRID/s8/pwwq2s.mpg
+lip/GRID/s8/pwwx5n.mpg
+lip/GRID/s8/sbag3p.mpg
+lip/GRID/s8/sbbn2a.mpg
+lip/GRID/s8/sbbt3n.mpg
+lip/GRID/s8/sbbt4s.mpg
+lip/GRID/s8/sbif7n.mpg
+lip/GRID/s8/sbif9p.mpg
+lip/GRID/s8/sbim4a.mpg
+lip/GRID/s8/sbis5n.mpg
+lip/GRID/s8/sbwh1p.mpg
+lip/GRID/s8/sbwt8s.mpg
+lip/GRID/s8/sbwuza.mpg
+lip/GRID/s8/sgab8a.mpg
+lip/GRID/s8/sgai1p.mpg
+lip/GRID/s8/sgao5p.mpg
+lip/GRID/s8/sgao6a.mpg
+lip/GRID/s8/sgbczs.mpg
+lip/GRID/s8/sgbpza.mpg
+lip/GRID/s8/sgbv2s.mpg
+lip/GRID/s8/sgio1p.mpg
+lip/GRID/s8/sgiozs.mpg
+lip/GRID/s8/sgiu3n.mpg
+lip/GRID/s8/sgwc3n.mpg
+lip/GRID/s8/sgwi9p.mpg
+lip/GRID/s8/sgwjza.mpg
+lip/GRID/s8/sgwp4a.mpg
+lip/GRID/s8/sgwv7p.mpg
+lip/GRID/s8/sraa3n.mpg
+lip/GRID/s8/sraa6a.mpg
+lip/GRID/s8/srag8s.mpg
+lip/GRID/s8/srat6s.mpg
+lip/GRID/s8/srat7p.mpg
+lip/GRID/s8/srba8s.mpg
+lip/GRID/s8/srbh1n.mpg
+lip/GRID/s8/srbn5n.mpg
+lip/GRID/s8/srbn8a.mpg
+lip/GRID/s8/sria1p.mpg
+lip/GRID/s8/sriazs.mpg
+lip/GRID/s8/srit3p.mpg
+lip/GRID/s8/swab2a.mpg
+lip/GRID/s8/swau4a.mpg
+lip/GRID/s8/swbh9p.mpg
+lip/GRID/s8/swbiza.mpg
+lip/GRID/s8/swbu5n.mpg
+lip/GRID/s8/swbu6s.mpg
+lip/GRID/s8/swin3n.mpg
+lip/GRID/s8/swwb7n.mpg
+lip/GRID/s8/swwi2s.mpg
+lip/GRID/s8/swwo5n.mpg
+lip/GRID/s9/bbay6n.mpg
+lip/GRID/s9/bbbe9s.mpg
+lip/GRID/s9/bbbr7s.mpg
+lip/GRID/s9/bbbr8p.mpg
+lip/GRID/s9/bbbz2p.mpg
+lip/GRID/s9/bbiq8n.mpg
+lip/GRID/s9/bbirzp.mpg
+lip/GRID/s9/bbiy2n.mpg
+lip/GRID/s9/bbwf2n.mpg
+lip/GRID/s9/bbwf3s.mpg
+lip/GRID/s9/bbwl9a.mpg
+lip/GRID/s9/bgaa1a.mpg
+lip/GRID/s9/bgag5a.mpg
+lip/GRID/s9/bgam8p.mpg
+lip/GRID/s9/bgat1s.mpg
+lip/GRID/s9/bgim2n.mpg
+lip/GRID/s9/bgim3s.mpg
+lip/GRID/s9/bgim4p.mpg
+lip/GRID/s9/bgis9a.mpg
+lip/GRID/s9/bgwh3a.mpg
+lip/GRID/s9/bgwu1a.mpg
+lip/GRID/s9/braf1s.mpg
+lip/GRID/s9/braf3a.mpg
+lip/GRID/s9/brbf7a.mpg
+lip/GRID/s9/brbs2n.mpg
+lip/GRID/s9/brbs5a.mpg
+lip/GRID/s9/brbz7s.mpg
+lip/GRID/s9/brilzn.mpg
+lip/GRID/s9/brir6p.mpg
+lip/GRID/s9/brir7a.mpg
+lip/GRID/s9/briy8n.mpg
+lip/GRID/s9/brizzp.mpg
+lip/GRID/s9/brwm5a.mpg
+lip/GRID/s9/brws7s.mpg
+lip/GRID/s9/brws8p.mpg
+lip/GRID/s9/brws9a.mpg
+lip/GRID/s9/bwaf9a.mpg
+lip/GRID/s9/bwam1s.mpg
+lip/GRID/s9/bwas5s.mpg
+lip/GRID/s9/bwif2n.mpg
+lip/GRID/s9/bwis3a.mpg
+lip/GRID/s9/bwwg5s.mpg
+lip/GRID/s9/bwwm8n.mpg
+lip/GRID/s9/bwwn1a.mpg
+lip/GRID/s9/bwwt4p.mpg
+lip/GRID/s9/lbac9s.mpg
+lip/GRID/s9/lbap6n.mpg
+lip/GRID/s9/lbap7s.mpg
+lip/GRID/s9/lbax1s.mpg
+lip/GRID/s9/lbbd3s.mpg
+lip/GRID/s9/lbbj6n.mpg
+lip/GRID/s9/lbbqzn.mpg
+lip/GRID/s9/lbic6p.mpg
+lip/GRID/s9/lbii8n.mpg
+lip/GRID/s9/lbiv8p.mpg
+lip/GRID/s9/lbwd6n.mpg
+lip/GRID/s9/lbwd8p.mpg
+lip/GRID/s9/lbwq5s.mpg
+lip/GRID/s9/lbwx8n.mpg
+lip/GRID/s9/lgar6p.mpg
+lip/GRID/s9/lgar7a.mpg
+lip/GRID/s9/lgbf2p.mpg
+lip/GRID/s9/lgbf3a.mpg
+lip/GRID/s9/lgbfzn.mpg
+lip/GRID/s9/lgbl5s.mpg
+lip/GRID/s9/lgbl7a.mpg
+lip/GRID/s9/lgie5a.mpg
+lip/GRID/s9/lgwm1a.mpg
+lip/GRID/s9/lgws3s.mpg
+lip/GRID/s9/lgws5a.mpg
+lip/GRID/s9/lgwz8p.mpg
+lip/GRID/s9/lrad4n.mpg
+lip/GRID/s9/lrad6p.mpg
+lip/GRID/s9/lrad7a.mpg
+lip/GRID/s9/lraj9s.mpg
+lip/GRID/s9/lraq5a.mpg
+lip/GRID/s9/lrbezp.mpg
+lip/GRID/s9/lrbk5a.mpg
+lip/GRID/s9/lriqzp.mpg
+lip/GRID/s9/lrix5a.mpg
+lip/GRID/s9/lrwe2n.mpg
+lip/GRID/s9/lrwe4p.mpg
+lip/GRID/s9/lrwr2p.mpg
+lip/GRID/s9/lrwr3a.mpg
+lip/GRID/s9/lrwy5s.mpg
+lip/GRID/s9/lwae1s.mpg
+lip/GRID/s9/lwae2p.mpg
+lip/GRID/s9/lwak6p.mpg
+lip/GRID/s9/lway2n.mpg
+lip/GRID/s9/lwbl1a.mpg
+lip/GRID/s9/lwbr5a.mpg
+lip/GRID/s9/lwby6n.mpg
+lip/GRID/s9/lwby8p.mpg
+lip/GRID/s9/lwid7s.mpg
+lip/GRID/s9/lwiq4n.mpg
+lip/GRID/s9/lwwl4p.mpg
+lip/GRID/s9/pbah8p.mpg
+lip/GRID/s9/pbao3a.mpg
+lip/GRID/s9/pbaozn.mpg
+lip/GRID/s9/pbau5s.mpg
+lip/GRID/s9/pbbo6p.mpg
+lip/GRID/s9/pbbo7a.mpg
+lip/GRID/s9/pbbvzp.mpg
+lip/GRID/s9/pbia9s.mpg
+lip/GRID/s9/pbih3s.mpg
+lip/GRID/s9/pbih5a.mpg
+lip/GRID/s9/pbiu1s.mpg
+lip/GRID/s9/pbiu2p.mpg
+lip/GRID/s9/pbwc3a.mpg
+lip/GRID/s9/pbwv5a.mpg
+lip/GRID/s9/pgaj7a.mpg
+lip/GRID/s9/pgbj8n.mpg
+lip/GRID/s9/pgbx9a.mpg
+lip/GRID/s9/pgic8p.mpg
+lip/GRID/s9/pgij3a.mpg
+lip/GRID/s9/pgip6p.mpg
+lip/GRID/s9/pgwd9s.mpg
+lip/GRID/s9/pgwk3s.mpg
+lip/GRID/s9/pgwy3a.mpg
+lip/GRID/s9/pgwyzn.mpg
+lip/GRID/s9/prab9s.mpg
+lip/GRID/s9/prao9a.mpg
+lip/GRID/s9/prbp3a.mpg
+lip/GRID/s9/prbpzn.mpg
+lip/GRID/s9/prih8n.mpg
+lip/GRID/s9/prwc7s.mpg
+lip/GRID/s9/prwjzn.mpg
+lip/GRID/s9/prwp5s.mpg
+lip/GRID/s9/pwai8n.mpg
+lip/GRID/s9/pwai9s.mpg
+lip/GRID/s9/pwap3s.mpg
+lip/GRID/s9/pwav8p.mpg
+lip/GRID/s9/pwbc8n.mpg
+lip/GRID/s9/pwbdzp.mpg
+lip/GRID/s9/pwbj4p.mpg
+lip/GRID/s9/pwbp7s.mpg
+lip/GRID/s9/pwbxzn.mpg
+lip/GRID/s9/pwii5s.mpg
+lip/GRID/s9/pwwj8p.mpg
+lip/GRID/s9/sbagzn.mpg
+lip/GRID/s9/sbas8n.mpg
+lip/GRID/s9/sbba2p.mpg
+lip/GRID/s9/sbbt5a.mpg
+lip/GRID/s9/sbif7s.mpg
+lip/GRID/s9/sbim3a.mpg
+lip/GRID/s9/sbwa4n.mpg
+lip/GRID/s9/sbwg8n.mpg
+lip/GRID/s9/sbwg9s.mpg
+lip/GRID/s9/sbwn2n.mpg
+lip/GRID/s9/sbwn5a.mpg
+lip/GRID/s9/sbwt8p.mpg
+lip/GRID/s9/sbwt9a.mpg
+lip/GRID/s9/sgab5s.mpg
+lip/GRID/s9/sgab6p.mpg
+lip/GRID/s9/sgai1a.mpg
+lip/GRID/s9/sgau6n.mpg
+lip/GRID/s9/sgau7s.mpg
+lip/GRID/s9/sgbb8n.mpg
+lip/GRID/s9/sgbb9s.mpg
+lip/GRID/s9/sgbi3s.mpg
+lip/GRID/s9/sgbi4p.mpg
+lip/GRID/s9/sgiozp.mpg
+lip/GRID/s9/sgiu3s.mpg
+lip/GRID/s9/sgiu4p.mpg
+lip/GRID/s9/sgwp2p.mpg
+lip/GRID/s9/sgwv5s.mpg
+lip/GRID/s9/sgwv7a.mpg
+lip/GRID/s9/sraa5a.mpg
+lip/GRID/s9/srag9a.mpg
+lip/GRID/s9/sranzn.mpg
+lip/GRID/s9/srat6p.mpg
+lip/GRID/s9/srbt8n.mpg
+lip/GRID/s9/srbt9s.mpg
+lip/GRID/s9/sriazp.mpg
+lip/GRID/s9/srit2p.mpg
+lip/GRID/s9/sritzn.mpg
+lip/GRID/s9/srwh6p.mpg
+lip/GRID/s9/srwh7a.mpg
+lip/GRID/s9/srwu4p.mpg
+lip/GRID/s9/srwu5a.mpg
+lip/GRID/s9/swbb2n.mpg
+lip/GRID/s9/swbb4p.mpg
+lip/GRID/s9/swbh8p.mpg
+lip/GRID/s9/swbo1s.mpg
+lip/GRID/s9/swin2n.mpg
+lip/GRID/s9/swin4p.mpg
+lip/GRID/s9/swit6n.mpg
+lip/GRID/s9/swwb6n.mpg
+lip/GRID/s9/swwu8n.mpg
+lip/GRID/s9/swwu9s.mpg

dataset.py

@@ -0,0 +1,714 @@
+# encoding: utf-8
+import numpy as np
+import glob
+import time
+import cv2
+import yaml
+import os
+import torch
+import glob
+import re
+import string
+import copy
+import json
+import random
+import enum
+import editdistance
+import pronouncing
+
+from torch.utils.data import Dataset
+
+import Extractor
+import options
+from cvtransforms import *
+from typing import List, Iterable
+from helpers import *
+
+
+class CharMap(str, enum.Enum):
+    letters = 'letters'
+    lsr2_text = 'lsr2_text'
+    phonemes = 'phonemes'
+    cmu_phonemes = 'cmu_phonemes'
+    visemes = 'visemes'
+
+
+class Datasets(str, enum.Enum):
+    GRID = 'GRID'
+    LRS2 = 'LRS2'
+
+
+class GridDataset(Dataset):
+    letters = [
+        ' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+        'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+        'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
+    ]
+    lrs2_chars = [
+        ' ', "'", '0', '1', '2', '3', '4', '5', '6', '7', '8',
+        '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+        'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+        'V', 'W', 'X', 'Y', 'Z'
+    ]
+    # phonemes used by the lipnet dataset
+    phonemes = [
+        ' ', 'AE1', 'AO1', 'D', 'JH', 'Y', 'P', 'AH0', 'OW1', 'G',
+        'AY1', 'TH', 'IY1', 'CH', 'T', 'AW1', 'F', 'AH1', 'Z',
+        'R', 'EH1', 'UW1', 'M', 'B', 'W', 'V', 'DH', 'K', 'IH0',
+        'AA1', 'IH1', 'S', 'EY1', 'N', 'OW0', 'L'
+    ]
+    # full set of phonemes in the CMU phoneme corpus
+    cmu_phonemes = [
+        ' ', '#', 'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1',
+        'AE2', 'AH', 'AH0', 'AH1', 'AH2', 'AO', 'AO0', 'AO1', 'AO2',
+        'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0', 'AY1', 'AY2',
+        'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER',
+        'ER0', 'ER1', 'ER2', 'EY', 'EY0', 'EY1', 'EY2', 'F', 'G',
+        'HH', 'IH', 'IH0', 'IH1', 'IH2', 'IY', 'IY0', 'IY1', 'IY2',
+        'JH', 'K', 'L', 'M', 'N', 'NG', 'OW', 'OW0', 'OW1', 'OW2',
+        'OY', 'OY0', 'OY1', 'OY2', 'P', 'R', 'S', 'SH', 'T', 'TH',
+        'UH', 'UH0', 'UH1', 'UH2', 'UW', 'UW0', 'UW1', 'UW2', 'V',
+        'W', 'Y', 'Z', 'ZH'
+    ]
+
+    phoneme_chars = map_phonemes(phonemes)
+    cmu_phoneme_chars = map_phonemes(cmu_phonemes)
+
+    def __init__(
+        self, video_path, alignments_dir,
+        phonemes_dir, file_list, vid_pad,
+        image_dir, txt_pad, phase, shared_dict=None,
+        char_map=CharMap.letters, base_dir='',
+        frame_doubling=False, sample_all_props=False
+    ):
+        self.base_dir = base_dir
+        self.sample_all_props = sample_all_props
+
+        self.image_dir = os.path.join(base_dir, image_dir)
+        self.alignments_dir = os.path.join(base_dir, alignments_dir)
+        self.phonemes_dir = os.path.join(base_dir, phonemes_dir)
+        self.frame_doubling = frame_doubling
+
+        if type(file_list) is str:
+            file_list = os.path.join(base_dir, file_list)
+            # print('FILE_LIST', file_list, base_dir)
+            file_list = open(file_list, 'r').readlines()
+
+        self.shared_dict = shared_dict
+        self.char_map = char_map
+
+        self.vid_pad = vid_pad
+        self.txt_pad = txt_pad
+        self.phase = phase
+
+        self.videos = [
+            os.path.join(video_path, line.strip())
+            for line in file_list
+        ]
+
+        self.data = []
+        for vid in self.videos:
+            items = vid.split(os.path.sep)
+            if len(items) < 2:
+                print('BAD VID ITEM', items)
+                raise ValueError
+
+            speaker_name, filename = items[-2], items[-1]
+            self.data.append((vid, speaker_name, filename))
+
+    def _fetch_anno_path(self, spk, basename):
+        return self.fetch_anno_path(
+            spk=spk, basename=basename, char_map=self.char_map
+        )
+
+    @classmethod
+    def text_to_phonemes(
+        cls, text, as_str=True, char_map=CharMap.phonemes
+    ):
+        sentence_phonemes = []
+
+        words = text.upper().strip().split(' ')
+        for word in words:
+            word_phonemes = pronouncing.phones_for_word(word)[0]
+            word_phonemes = word_phonemes.split(' ')
+            sentence_phonemes.extend(word_phonemes)
+            sentence_phonemes.append(' ')
+
+        if sentence_phonemes[-1] == ' ':
+            sentence_phonemes = sentence_phonemes[:-1]
+
+        if as_str:
+            return cls.stringify(sentence_phonemes, char_map=char_map)
+        else:
+            return sentence_phonemes
+
+    def fetch_anno_path(self, spk, basename, char_map):
+        if char_map == CharMap.letters:
+            align_path_name = os.path.join(
+                self.alignments_dir, spk, basename + '.align'
+            )
+            return align_path_name
+        elif char_map == CharMap.lsr2_text:
+            align_path_name = os.path.join(
+                self.alignments_dir, spk, basename + '.txt'
+            )
+            return align_path_name
+        elif char_map == CharMap.phonemes:
+            phonemes_path_name = os.path.join(
+                self.phonemes_dir, spk, basename + '.align'
+            )
+            return phonemes_path_name
+        elif char_map == CharMap.cmu_phonemes:
+            phonemes_path_name = os.path.join(
+                self.phonemes_dir, spk, basename + '.txt'
+            )
+            return phonemes_path_name
+        else:
+            raise NotImplementedError
+
+    def fetch_anno_text(self, spk, basename, char_map: CharMap):
+        return self.load_anno_text(self.fetch_anno_path(
+            spk, basename, char_map=char_map
+        ), char_map=char_map)
+
+    def __getitem__(self, idx):
+        (vid, spk, name) = self.data[idx]
+        return self.load_sample(
+            video_name=vid, speaker_name=spk,
+            filename=name
+        )
+
+    def load_random_sample(self, char_map=None):
+        (vid, spk, name) = random.choice(self.data)
+        return self.load_sample(
+            video_name=vid, speaker_name=spk,
+            filename=name, char_map=char_map
+        )
+
+    def load_sample(
+        self, video_name, speaker_name, filename,
+        char_map=None
+    ):
+        if char_map is None:
+            char_map = self.char_map
+        if self.sample_all_props:
+            char_map = all
+
+        vid = self.load_vid(video_name)
+        if self.frame_doubling:
+            vid = np.repeat(vid, repeats=2, axis=0)
+
+        basename, _ = os.path.splitext(filename)
+        # print('SPK_NAME', (spk, name, anno_path))
+        txt_results, phoneme_results = {}, {}
+        cmu_phoneme_results = {}
+
+        if (char_map is all) or (char_map == CharMap.letters):
+            txt_anno, txt_anno_arr = self.fetch_anno_text(
+                speaker_name, basename, char_map=CharMap.letters
+            )
+
+            txt_anno_arr_len = txt_anno_arr.shape[0]
+            txt_anno_arr = self._padding(txt_anno_arr, self.txt_pad)
+            assert not np.isnan(txt_anno_arr).any()
+
+            txt_anno += [' '] * (options.txt_padding - len(txt_anno))
+            txt_results = kwargify(
+                txt=torch.LongTensor(txt_anno_arr),
+                txt_len=txt_anno_arr_len, txt_anno=txt_anno
+            )
+
+        if (char_map is all) or (char_map == CharMap.phonemes):
+            phoneme_anno, phoneme_anno_arr = self.fetch_anno_text(
+                speaker_name, basename, char_map=CharMap.phonemes
+            )
+
+            phoneme_anno_arr_len = phoneme_anno_arr.shape[0]
+            phoneme_anno_arr = self._padding(
+                phoneme_anno_arr, self.txt_pad
+            )
+            assert not np.isnan(phoneme_anno_arr_len).any()
+
+            phoneme_results = kwargify(
+                phonemes=torch.LongTensor(phoneme_anno_arr),
+                phonemes_len=phoneme_anno_arr_len,
+            )
+
+        elif (char_map is all) or (char_map == CharMap.cmu_phonemes):
+            phoneme_anno, phoneme_anno_arr = self.fetch_anno_text(
+                speaker_name, basename, char_map=CharMap.cmu_phonemes
+            )
+
+            phoneme_anno_arr_len = phoneme_anno_arr.shape[0]
+            phoneme_anno_arr = self._padding(
+                phoneme_anno_arr, self.txt_pad
+            )
+            assert not np.isnan(phoneme_anno_arr_len).any()
+
+            cmu_phoneme_results = kwargify(
+                cmu_phonemes=torch.LongTensor(phoneme_anno_arr),
+                cmu_phonemes_len=phoneme_anno_arr_len,
+            )
+
+        if self.phase == 'train':
+            vid = HorizontalFlip(vid)
+
+        vid = ColorNormalize(vid)
+        vid_len = vid.shape[0]
+        vid = self._padding(vid, self.vid_pad)
+
+        """
+        if vid_len <= anno_len * 2:
+            raise ValueError(f'CTC INVALID: {self.data[idx]}')
+        """
+
+        assert not np.isnan(vid).any()
+
+        return kwargify(
+            vid=torch.FloatTensor(vid.transpose(3, 0, 1, 2)),
+            vid_len=vid_len, **txt_results, **phoneme_results,
+            **cmu_phoneme_results
+        )
+
+    def __len__(self):
+        return len(self.data)
+
+    @staticmethod
+    def serialize(data: np.ndarray):
+        return torch.from_numpy(data.astype(np.uint8))
+
+    @staticmethod
+    def deserialize(data: torch.Tensor):
+        return data.numpy().astype(np.float16)
+
+    @staticmethod
+    def process_vid(video_path: str, to_tensor=True):
+        frames = Extractor.extract_frames(
+            video_path, recycle_landmarks=True, use_gpu=True
+        )
+
+        frames = [f for f in frames if f is not None]
+        array = list(filter(lambda im: im is not None, frames))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+
+        array = np.stack(array, axis=0).astype(np.float16)
+        vid = ColorNormalize(array)
+
+        if to_tensor:
+            vid = torch.FloatTensor(vid.transpose(3, 0, 1, 2))
+
+        return vid
+
+    def load_vid(self, video_path: str) -> np.ndarray:
+        return self._load_vid(video_path, cache=False)
+
+    def _load_vid(self, video_path: str, cache=True) -> np.ndarray:
+        if cache and self.shared_dict is not None:
+            if video_path in self.shared_dict:
+                return self.deserialize(
+                    self.shared_dict[video_path]
+                )
+
+        # print('LOAD_DIR', video_path)
+        base_filename = os.path.basename(video_path)
+        basename, _ = os.path.splitext(base_filename)
+        speaker_dir = os.path.basename(os.path.dirname(video_path))
+        image_dir = f'{self.image_dir}/{speaker_dir}/{basename}'
+
+        files = os.listdir(image_dir)
+        files = list(filter(lambda file: file.find('.jpg') != -1, files))
+        files = sorted(files, key=lambda file: int(os.path.splitext(file)[0]))
+        array = [cv2.imread(os.path.join(image_dir, file)) for file in files]
+        array = list(filter(lambda im: im is not None, array))
+        array = [
+            cv2.resize(im, (128, 64), interpolation=cv2.INTER_LANCZOS4)
+            for im in array
+        ]
+
+        try:
+            array = np.stack(array, axis=0).astype(np.float16)
+        except ValueError as e:
+            print(f'BAD VIDEO PATH: {video_path}')
+            raise e
+
+        if cache and self.shared_dict is not None:
+            # print('SD >>')
+            serialized_data = self.serialize(array)
+            serialized_data.share_memory_()
+            self.shared_dict[video_path] = serialized_data
+            # print('SD <<')
+
+        return array
+
+    @classmethod
+    def load_anno(cls, name, char_map):
+        return cls.load_anno_text(name, char_map)[1]
+
+    @classmethod
+    def load_anno_text(cls, name, char_map):
+        # print('ANNOTATION_NAME', name)
+        txt = cls.load_sentence(name, char_map=char_map)
+        indices = cls.txt2arr(txt, 1, char_map=char_map)
+        # print('TXT', txt)
+        return txt, indices
+
+    def _load_anno(self, name):
+        return self.load_anno(name, self.char_map)
+
+    @classmethod
+    def load_sentence(cls, name, char_map=CharMap.letters) -> List[str]:
+        with open(name, 'r') as f:
+            if char_map == CharMap.letters:
+                lines = [line.strip().split(' ') for line in f.readlines()]
+                txt = [line[2] for line in lines]
+                txt = list(filter(
+                    lambda s: not s.upper() in ['SIL', 'SP'], txt
+                ))
+
+                all_chars = list(' '.join(txt))
+                all_chars = [char.upper() for char in all_chars]
+                return all_chars
+
+            elif char_map == CharMap.lsr2_text:
+                text_line = f.readlines()[0]
+                text_line = text_line[5:].strip()
+                all_chars = [char.upper() for char in text_line]
+                return all_chars
+
+            elif char_map in (CharMap.phonemes, CharMap.cmu_phonemes):
+                all_chars = []
+
+                for line in f.readlines():
+                    word_phonemes = line.strip().split(' ')
+                    all_chars.extend(word_phonemes)
+                    all_chars.append(' ')
+
+                if all_chars[-1] == ' ':
+                    all_chars = all_chars[:-1]
+
+                return all_chars
+            else:
+                raise ValueError(f'BAD CHAR MAP {char_map}')
+
+    @classmethod
+    def load_str_sentence(cls, name, char_map=CharMap.letters) -> str:
+        chars_seq = cls.load_sentence(name=name, char_map=char_map)
+        return cls.stringify(chars_seq, char_map=char_map)
+
+    @staticmethod
+    def tokenize_text(text: str, word_tokenize=False) -> List[str]:
+        """
+        :param text:
+        :param word_tokenize:
+        whether to tokenize into words or individual characters
+        :return:
+        """
+        if word_tokenize:
+            return text.split(' ')
+        else:
+            return list(text)
+
+    @staticmethod
+    def tokenize_phonemes(text: str, word_tokenize=False) -> List[str]:
+        """
+        :param text:
+        :param word_tokenize:
+        whether to tokenize into words or individual phonemes
+        example:
+        text = 'S-EH1-T G-R-IY1-N IH0-N EH1-L S-IH1-K-S AH0-G-EH1-N'
+        word-level tokens:
+        ['S-EH1-T', 'G-R-IY1-N', 'IH0-N', 'EH1-L', 'S-IH1-K-S', 'AH0-G-EH1-N']
+        phoneme-level tokens:
+        ['S', 'EH1', 'T', ' ', 'G', 'R', 'IY1', 'N', ' ', 'IH0',
+        'N', ' ', 'EH1', 'L', ' ', 'S', 'IH1', 'K', 'S', ' ',
+        'AH0', 'G', 'EH1', 'N']
+        :return:
+        """
+        if word_tokenize:
+            return text.split(' ')
+        else:
+            words = text.split(' ')
+            phonemes = []
+
+            for word in words:
+                assert not word.startswith('-')
+                assert not word.endswith('-')
+                phonemes.extend(word.split('-'))
+                phonemes.append(' ')
+
+            if phonemes[-1] == ' ':
+                phonemes = phonemes[:-1]
+
+            return phonemes
+
+    @staticmethod
+    def _padding(array, length):
+        array = [array[_] for _ in range(array.shape[0])]
+        size = array[0].shape
+
+        for i in range(length - len(array)):
+            array.append(np.zeros(size))
+
+        return np.stack(array, axis=0)
+
+    @classmethod
+    def txt2arr(cls, txt, start, char_map=CharMap.letters):
+        arr = []
+
+        if char_map == CharMap.letters:
+            for char in list(txt):
+                arr.append(cls.letters.index(char) + start)
+
+        elif char_map == CharMap.phonemes:
+            # print('TXT', txt)
+            for phoneme in txt:
+                arr.append(cls.phonemes.index(phoneme) + start)
+
+        elif char_map == CharMap.cmu_phonemes:
+            # print('TXT', txt)
+            for phoneme in txt:
+                arr.append(cls.cmu_phonemes.index(phoneme) + start)
+
+        elif char_map == CharMap.visemes:
+            raise NotImplementedError
+        else:
+            raise ValueError(f'BAD CHAR MAP: {char_map}')
+
+        return np.array(arr)
+
+    def arr2txt(self, arr, start, char_map=None):
+        char_map = self.char_map if char_map is None else char_map
+        return self._arr2txt(arr, start, char_map=char_map)
+
+    @classmethod
+    def _arr2txt(cls, arr, start, char_map=CharMap.letters):
+        txt = []
+
+        for n in arr:
+            if n >= start:
+                if char_map == CharMap.letters:
+                    txt.append(cls.letters[n - start])
+                elif char_map == CharMap.phonemes:
+                    txt.append(cls.phonemes[n - start])
+                elif char_map == CharMap.cmu_phonemes:
+                    txt.append(cls.cmu_phonemes[n - start])
+                elif char_map == CharMap.visemes:
+                    raise NotImplementedError
+                else:
+                    raise ValueError(f'BAD CHAR MAP: {char_map}')
+
+        return cls.stringify(txt, char_map)
+
+    def get_char_mapping(self):
+        return self.char_mapping(self.char_map)
+
+    @classmethod
+    def char_mapping(cls, char_map):
+        if char_map == CharMap.letters:
+            return cls.letters
+        elif char_map == CharMap.phonemes:
+            return cls.phonemes
+        elif char_map == CharMap.cmu_phonemes:
+            return cls.cmu_phonemes
+        elif char_map == CharMap.visemes:
+            raise NotImplementedError
+        else:
+            raise ValueError(f'BAD CHAR MAP: {char_map}')
+
+    def ctc_decode(self, y):
+        y = y.argmax(-1)
+        return [
+            self.ctc_arr2txt(y[_], start=1)
+            for _ in range(y.size(0))
+        ]
+
+    def ctc_decode_indices(self, y):
+        y = y.argmax(-1)
+        return [
+            self.ctc_arr2txt_indices(y[_], start=1)[1]
+            for _ in range(y.size(0))
+        ]
+
+    def ctc_arr2txt(self, *args, **kwargs):
+        sentence, indices = self.ctc_arr2txt_pair(*args, **kwargs)
+        return sentence
+
+    def ctc_arr2txt_pair(
+        self, arr, start, char_map=None,
+        filter_previous=True
+    ):
+        """
+        converts token indices into a string sentence
+
+        :param arr:
+        array of token indices
+        :param start:
+        number of special characters in character set
+        :param char_map:
+        character set to use for tokenization
+        :param filter_previous:
+        if True, removes consecutive occurrences of an index / token
+        e.g. THREE becomes THRE, SOON becomes SON
+        :return:
+        """
+        sentence, indices = self.ctc_arr2txt_indices(
+            arr=arr, start=start, char_map=char_map,
+            filter_previous=filter_previous
+        )
+        return sentence, indices
+
+    def ctc_arr2txt_indices(
+        self, arr, start, char_map=None,
+        filter_previous=True
+    ):
+        """
+        converts token indices into a string sentence
+        and indices of tokens taken along arr
+
+        :param arr:
+        array of token indices
+        :param start:
+        number of special characters in character set
+        :param char_map:
+        character set to use for tokenization
+        :param filter_previous:
+        if True, removes consecutive occurrences of an index / token
+        e.g. THREE becomes THRE, SOON becomes SON
+        :return:
+        """
+        if char_map is None:
+            char_map = self.char_map
+
+        previous = -1
+        txt, indices = [], []
+        char_mapping = self.char_mapping(char_map)
+
+        for k, n in enumerate(arr):
+            check_consecutive = (
+                not filter_previous or previous != n
+            )
+            if n >= start:
+                has_empty_char = (
+                    len(txt) > 0 and txt[-1] == ' ' and
+                    char_mapping[n - start] == ' '
+                )
+
+                if not has_empty_char and check_consecutive:
+                    txt.append(char_mapping[n - start])
+                    indices.append(k)
+
+            previous = n
+
+        sentence = self.stringify(txt, char_map)
+        return sentence, indices
+
+    @staticmethod
+    def stringify(txt, char_map):
+        if char_map in (CharMap.letters, CharMap.lsr2_text):
+            return ''.join(txt).strip()
+        elif char_map in (CharMap.phonemes, CharMap.cmu_phonemes):
+            sentence = '-'.join(txt).strip()
+            sentence = sentence.replace('- ', ' ')
+            sentence = sentence.replace(' -', ' ')
+            if sentence.endswith('-'): sentence = sentence[:-1]
+            if sentence.startswith('-'): sentence = sentence[1:]
+            return sentence
+        else:
+            raise NotImplementedError
+
+    def _map_chars(self, chars: str):
+        return self.map_chars(chars, char_map=self.char_map)
+
+    @classmethod
+    def map_chars(cls, chars: str, char_map: CharMap):
+        # map a string containing multi-character
+        # phonemes like AE1 to a single character
+
+        if char_map == CharMap.letters:
+            return chars
+        elif char_map in (CharMap.phonemes, CharMap.cmu_phonemes):
+            if char_map == CharMap.phonemes:
+                phonemes_arr = cls.phonemes
+                char_phonemes_arr = cls.phonemes
+            elif char_map == CharMap.cmu_phonemes:
+                phonemes_arr = cls.cmu_phonemes
+                char_phonemes_arr = cls.cmu_phoneme_chars
+            else:
+                raise ValueError(f'BAD CHAR MAP {char_map}')
+
+            words = chars.split(' ')
+            char_phonemes = ''
+
+            for word in words:
+                phonemes = word.split('-')
+                phonemes = [
+                    phoneme for phoneme in phonemes
+                    if phoneme.strip() != ''
+                ]
+
+                for phoneme in phonemes:
+                    char_phonemes += char_phonemes_arr[
+                        phonemes_arr.index(phoneme)
+                    ]
+
+                char_phonemes += ' '
+
+            return char_phonemes
+        elif char_map == CharMap.visemes:
+            raise NotImplementedError
+        else:
+            raise ValueError(f'BAD CHAR MAP: {char_map}')
+
+    @classmethod
+    def map_char_lists(
+        cls, char_lists: Iterable[str], char_map: CharMap
+    ):
+        return [cls.map_chars(
+            char_seq, char_map=char_map
+        ) for char_seq in char_lists]
+
+    def wer(self, raw_predict, raw_truth):
+        return self.get_wer(
+            raw_predict, raw_truth, char_map=self.char_map
+        )
+
+    @classmethod
+    def get_wer(cls, raw_predict, raw_truth, char_map: CharMap):
+        assert isinstance(raw_predict, Iterable)
+        assert isinstance(raw_truth, Iterable)
+
+        predict = cls.map_char_lists(raw_predict, char_map=char_map)
+        truth = cls.map_char_lists(raw_truth, char_map=char_map)
+        # print('WER', raw_truth, raw_predict)
+
+        word_pairs = [
+            (p[0].split(' '), p[1].split(' '))
+            for p in zip(predict, truth)
+        ]
+        wer = [
+            1.0 * editdistance.eval(p[0], p[1])/len(p[1])
+            for p in word_pairs
+        ]
+        return wer
+
+    def cer(self, raw_predict, raw_truth):
+        return self.get_cer(
+            raw_predict, raw_truth, char_map=self.char_map
+        )
+
+    @classmethod
+    def get_cer(cls, raw_predict, raw_truth, char_map: CharMap):
+        assert isinstance(raw_predict, Iterable)
+        assert isinstance(raw_truth, Iterable)
+
+        predict = cls.map_char_lists(raw_predict, char_map=char_map)
+        truth = cls.map_char_lists(raw_truth, char_map=char_map)
+
+        cer = [
+            1.0 * editdistance.eval(p[0], p[1]) / len(p[1])
+            for p in zip(predict, truth)
+        ]
+        return cer

dataset_test.py

@@ -0,0 +1,52 @@
+import options as opt
+import matplotlib.pyplot as plt
+import torch.optim as optim
+import numpy as np
+import time
+
+from dataset import GridDataset
+from torch.utils.data import DataLoader
+
+
+def dataset2dataloader(
+    dataset, num_workers=opt.num_workers, shuffle=True
+):
+    return DataLoader(
+        dataset,
+        batch_size=opt.batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers,
+        drop_last=False
+    )
+
+
+dataset = GridDataset(
+    video_path=opt.video_path,
+    alignments_dir=opt.alignments_dir,
+    file_list=opt.train_list,
+    vid_pad=opt.vid_padding,
+    image_dir=opt.images_dir,
+    txt_pad=opt.txt_padding,
+    phase='train'
+)
+
+loader = dataset2dataloader(dataset)
+
+
+def fetch_samples(num_samples=10):
+    samples = []
+    sample_no = 0
+
+    for sample in loader:
+        sample_no += 1
+        samples.append(sample)
+
+        if sample_no >= num_samples:
+            break
+
+    return samples
+
+
+samples = fetch_samples()
+print(samples[0])
+print('END')

demo.py

@@ -0,0 +1,169 @@
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+import math
+import os
+import sys
+from dataset import GridDataset
+import numpy as np
+import time
+from models.LipNet import LipNet
+import torch.optim as optim
+import re
+import json
+import tempfile
+import shutil
+import cv2
+import face_alignment
+
+
+def get_position(size, padding=0.25):
+    x = [0.000213256, 0.0752622, 0.18113, 0.29077, 0.393397, 0.586856, 0.689483, 0.799124,
+         0.904991, 0.98004, 0.490127, 0.490127, 0.490127, 0.490127, 0.36688, 0.426036,
+         0.490127, 0.554217, 0.613373, 0.121737, 0.187122, 0.265825, 0.334606, 0.260918,
+         0.182743, 0.645647, 0.714428, 0.793132, 0.858516, 0.79751, 0.719335, 0.254149,
+         0.340985, 0.428858, 0.490127, 0.551395, 0.639268, 0.726104, 0.642159, 0.556721,
+         0.490127, 0.423532, 0.338094, 0.290379, 0.428096, 0.490127, 0.552157, 0.689874,
+         0.553364, 0.490127, 0.42689]
+
+    y = [0.106454, 0.038915, 0.0187482, 0.0344891, 0.0773906, 0.0773906, 0.0344891,
+         0.0187482, 0.038915, 0.106454, 0.203352, 0.307009, 0.409805, 0.515625, 0.587326,
+         0.609345, 0.628106, 0.609345, 0.587326, 0.216423, 0.178758, 0.179852, 0.231733,
+         0.245099, 0.244077, 0.231733, 0.179852, 0.178758, 0.216423, 0.244077, 0.245099,
+         0.780233, 0.745405, 0.727388, 0.742578, 0.727388, 0.745405, 0.780233, 0.864805,
+         0.902192, 0.909281, 0.902192, 0.864805, 0.784792, 0.778746, 0.785343, 0.778746,
+         0.784792, 0.824182, 0.831803, 0.824182]
+
+    x, y = np.array(x), np.array(y)
+
+    x = (x + padding) / (2 * padding + 1)
+    y = (y + padding) / (2 * padding + 1)
+    x = x * size
+    y = y * size
+    return np.array(list(zip(x, y)))
+
+
+def cal_area(anno):
+    return (anno[:, 0].max() - anno[:, 0].min()) * (anno[:, 1].max() - anno[:, 1].min())
+
+
+def output_video(p, txt, dst):
+    files = os.listdir(p)
+    files = sorted(files, key=lambda x: int(os.path.splitext(x)[0]))
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+
+    for file, line in zip(files, txt):
+        img = cv2.imread(os.path.join(p, file))
+        h, w, _ = img.shape
+        img = cv2.putText(img, line, (w // 8, 11 * h // 12), font, 1.2, (0, 0, 0), 3, cv2.LINE_AA)
+        img = cv2.putText(img, line, (w // 8, 11 * h // 12), font, 1.2, (255, 255, 255), 0, cv2.LINE_AA)
+        h = h // 2
+        w = w // 2
+        img = cv2.resize(img, (w, h))
+        cv2.imwrite(os.path.join(p, file), img)
+
+    cmd = "ffmpeg -y -i {}/%d.jpg -r 25 \'{}\'".format(p, dst)
+    os.system(cmd)
+
+
+def transformation_from_points(points1, points2):
+    points1 = points1.astype(np.float64)
+    points2 = points2.astype(np.float64)
+
+    c1 = np.mean(points1, axis=0)
+    c2 = np.mean(points2, axis=0)
+    points1 -= c1
+    points2 -= c2
+    s1 = np.std(points1)
+    s2 = np.std(points2)
+    points1 /= s1
+    points2 /= s2
+
+    U, S, Vt = np.linalg.svd(points1.T * points2)
+    R = (U * Vt).T
+    return np.vstack([
+        np.hstack(((s2 / s1) * R,
+        c2.T - (s2 / s1) * R * c1.T)),
+        np.matrix([0., 0., 1.])
+    ])
+
+
+def load_video(file):
+    p = tempfile.mkdtemp()
+    cmd = 'ffmpeg -i \'{}\' -qscale:v 2 -r 25 \'{}/%d.jpg\''.format(file, p)
+    os.system(cmd)
+
+    files = os.listdir(p)
+    files = sorted(files, key=lambda x: int(os.path.splitext(x)[0]))
+
+    array = [cv2.imread(os.path.join(p, file)) for file in files]
+    array = list(filter(lambda im: not im is None, array))
+    # array = [cv2.resize(im, (100, 50), interpolation=cv2.INTER_LANCZOS4)
+    # for im in array]
+    fa = face_alignment.FaceAlignment(
+        face_alignment.LandmarksType.TWO_D,
+        flip_input=False, device='cuda'
+    )
+
+    points = [fa.get_landmarks(I) for I in array]
+
+    front256 = get_position(256)
+    video = []
+
+    for point, scene in zip(points, array):
+        if point is not None:
+            shape = np.array(point[0])
+            shape = shape[17:]
+            M = transformation_from_points(np.matrix(shape), np.matrix(front256))
+
+            img = cv2.warpAffine(scene, M[:2], (256, 256))
+            (x, y) = front256[-20:].mean(0).astype(np.int32)
+            w = 160 // 2
+            img = img[y - w // 2:y + w // 2, x - w:x + w, ...]
+            img = cv2.resize(img, (128, 64))
+            video.append(img)
+
+    video = np.stack(video, axis=0).astype(np.float32)
+    video = torch.FloatTensor(video.transpose(3, 0, 1, 2)) / 255.0
+
+    return video, p
+
+
+def ctc_decode(y):
+    y = y.argmax(-1)
+    t = y.size(0)
+    result = []
+    for i in range(t + 1):
+        result.append(GridDataset.ctc_arr2txt(y[:i], start=1))
+
+    return result
+
+
+if __name__ == '__main__':
+    opt = __import__('options')
+    os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu
+
+    model = LipNet()
+    model = model.cuda()
+    net = nn.DataParallel(model).cuda()
+
+    if hasattr(opt, 'weights'):
+        pretrained_dict = torch.load(opt.weights)
+        model_dict = model.state_dict()
+        pretrained_dict = {k: v for k, v in pretrained_dict.items() if
+                           k in model_dict.keys() and v.size() == model_dict[k].size()}
+        missed_params = [k for k, v in model_dict.items() if not k in pretrained_dict.keys()]
+        print('loaded params/tot params:{}/{}'.format(len(pretrained_dict), len(model_dict)))
+        print('miss matched params:{}'.format(missed_params))
+        model_dict.update(pretrained_dict)
+        model.load_state_dict(model_dict)
+
+    video, img_p = load_video(sys.argv[1])
+    y = model(video[None, ...].cuda())
+    txt = ctc_decode(y[0])
+
+    output_video(img_p, txt, sys.argv[2])
+    shutil.rmtree(img_p)

extract_lip.py

@@ -0,0 +1,149 @@
+import cv2
+import json
+import numpy as np
+from multiprocessing import Pool, Process, Queue
+import time
+import os
+
+
+def get_position(size, padding=0.25):
+    x = [0.000213256, 0.0752622, 0.18113, 0.29077, 0.393397, 0.586856, 0.689483, 0.799124,
+         0.904991, 0.98004, 0.490127, 0.490127, 0.490127, 0.490127, 0.36688, 0.426036,
+         0.490127, 0.554217, 0.613373, 0.121737, 0.187122, 0.265825, 0.334606, 0.260918,
+         0.182743, 0.645647, 0.714428, 0.793132, 0.858516, 0.79751, 0.719335, 0.254149,
+         0.340985, 0.428858, 0.490127, 0.551395, 0.639268, 0.726104, 0.642159, 0.556721,
+         0.490127, 0.423532, 0.338094, 0.290379, 0.428096, 0.490127, 0.552157, 0.689874,
+         0.553364, 0.490127, 0.42689]
+
+    y = [0.106454, 0.038915, 0.0187482, 0.0344891, 0.0773906, 0.0773906, 0.0344891,
+         0.0187482, 0.038915, 0.106454, 0.203352, 0.307009, 0.409805, 0.515625, 0.587326,
+         0.609345, 0.628106, 0.609345, 0.587326, 0.216423, 0.178758, 0.179852, 0.231733,
+         0.245099, 0.244077, 0.231733, 0.179852, 0.178758, 0.216423, 0.244077, 0.245099,
+         0.780233, 0.745405, 0.727388, 0.742578, 0.727388, 0.745405, 0.780233, 0.864805,
+         0.902192, 0.909281, 0.902192, 0.864805, 0.784792, 0.778746, 0.785343, 0.778746,
+         0.784792, 0.824182, 0.831803, 0.824182]
+
+    x, y = np.array(x), np.array(y)
+
+    x = (x + padding) / (2 * padding + 1)
+    y = (y + padding) / (2 * padding + 1)
+    x = x * size
+    y = y * size
+    return np.array(list(zip(x, y)))
+
+
+def cal_area(anno):
+    return (
+        (anno[:, 0].max() - anno[:, 0].min()) *
+        (anno[:, 1].max() - anno[:, 1].min())
+    )
+
+
+def transformation_from_points(points1, points2):
+    points1 = points1.astype(np.float64)
+    points2 = points2.astype(np.float64)
+
+    c1 = np.mean(points1, axis=0)
+    c2 = np.mean(points2, axis=0)
+    points1 -= c1
+    points2 -= c2
+    s1 = np.std(points1)
+    s2 = np.std(points2)
+    points1 /= s1
+    points2 /= s2
+
+    U, S, Vt = np.linalg.svd(points1.T * points2)
+    R = (U * Vt).T
+
+    return np.vstack([np.hstack((
+        (s2 / s1) * R, c2.T - (s2 / s1) * R * c1.T)),
+        np.matrix([0., 0., 1.])
+    ])
+
+
+def anno_img(img_dir, anno_dir, save_dir):
+    files = list(os.listdir(img_dir))
+    files = [file for file in files if (file.find('.jpg') != -1)]
+    shapes = []
+    for file in files:
+        img = os.path.join(img_dir, file)
+        anno = os.path.join(anno_dir, file).replace('.jpg', '.txt')
+
+        I = cv2.imread(img)
+        count = 0
+
+        with open(anno, 'r') as f:
+            annos = [line.strip().split('\t') for line in f.readlines()]
+            if len(annos) == 0: return
+            for (i, anno) in enumerate(annos):
+                x, y = [], []
+                for p in anno:
+                    _, __ = p[1:-1].split(',')
+                    _, __ = float(_), float(__)
+                    x.append(_)
+                    y.append(__)
+
+                annos[i] = np.stack([x, y], 1)
+
+        anno = sorted(annos, key=cal_area, reverse=True)[0]
+        shape = []
+
+        shapes.append(anno[17:])
+
+    front256 = get_position(256)
+    M_prev = None
+
+    for (shape, file) in zip(shapes, files):
+        img = os.path.join(img_dir, file)
+        I = cv2.imread(img)
+        M = transformation_from_points(np.matrix(shape), np.matrix(front256))
+        img = cv2.warpAffine(I, M[:2], (256, 256))
+        (x, y) = front256[-20:].mean(0).astype(np.int32)
+        w = 160 // 2
+        img = img[y - w // 2:y + w // 2, x - w:x + w, ...]
+        cv2.imwrite(os.path.join(save_dir, file), img)
+
+
+def run(files):
+    tic = time.time()
+    count = 0
+    print('n_files:{}'.format(len(files)))
+    for (img_dir, anno_dir, save_dir) in files:
+        anno_img(img_dir, anno_dir, save_dir)
+        count += 1
+        if count % 1000 == 0:
+            print('eta={}'.format(
+                (time.time() - tic) /
+                (count) * (len(files) - count) /
+                3600.0
+            ))
+
+
+if __name__ == '__main__':
+    with open('grid.txt', 'r') as f:
+        data = [line.strip() for line in f.readlines()]
+        data = list(set([os.path.split(file)[0] for file in data]))
+
+    annos = [name.replace('GRID/6k_video_imgs', 'GRID/landmarks') for name in data]
+    targets = [name.replace('GRID/6k_video_imgs', 'GRID/lip') for name in data]
+
+    for dst in targets:
+        if (not os.path.exists(dst)):
+            os.makedirs(dst)
+
+    data = list(zip(data, annos, targets))
+    processes = []
+    n_p = 8
+    bs = len(data) // n_p
+    for i in range(n_p):
+        if i == n_p - 1:
+            bs = len(data)
+
+        p = Process(target=run, args=(data[:bs],))
+        data = data[bs:]
+        p.start()
+        processes.append(p)
+
+    assert (len(data) == 0)
+    for p in processes:
+        p.join()

extract_lip_v2.py

@@ -0,0 +1,60 @@
+import os.path
+import sys
+
+from scripts import extract_lip
+from multiprocessing import Pool, Process, Queue
+from Loader import GridLoader
+from dataset import GridDataset
+from models.LipNet import LipNet
+
+PARALLEL = False
+
+loader = GridLoader()
+video_paths = loader.load_video_paths(fetch_all_paths=False)
+image_dirs, anno_dirs, target_dirs = [], [], []
+
+for k in range(1, 35):
+    speaker_name = f's{k}'
+    image_dirpath = f'lip/GRID_imgs/{speaker_name}'
+    annos_dirpath = f'lip/GRID_aligns/{speaker_name}'
+    target_dirpath = f'lip/GRID_lip_imgs/{speaker_name}'
+
+    if not os.path.exists(image_dirpath):
+        continue
+
+    sentences = os.listdir(image_dirpath)
+    for sentence in sentences:
+        sentence_dir = f'{image_dirpath}/{sentence}'
+        print('SS', sentence_dir)
+
+        image_dirs.append(sentence_dir)
+        anno_dirs.append(annos_dirpath)
+        target_dirs.append(target_dirpath)
+
+print(video_paths[:10])
+
+for dst in target_dirs:
+    if not os.path.exists(dst):
+        os.makedirs(dst)
+
+data = list(zip(image_dirs, anno_dirs, target_dirs))
+processes = []
+n_p = 8
+bs = len(data) // n_p
+
+if PARALLEL:
+    for i in range(n_p):
+        if i == n_p - 1:
+            bs = len(data)
+
+        p = Process(target=extract_lip.run, args=(data[:bs],))
+        data = data[bs:]
+        p.start()
+        processes.append(p)
+
+    assert (len(data) == 0)
+    for p in processes:
+        p.join()
+
+else:
+    extract_lip.run(data)

extract_lsr2_vocab.py

@@ -0,0 +1,16 @@
+from TranslatorTrainer import *
+
+vocab_filepaths = (
+    'data/lsr2_phoneme_vocab.pth',
+    'data/lsr2_text_char_vocab.pth'
+)
+
+trainer = TranslatorTrainer(
+    word_tokenize=False,
+    input_char_map=options.char_map,
+    output_char_map=options.text_char_map,
+    dataset_type=Datasets.LRS2
+)
+
+# trainer.train()
+trainer.save_vocabs(*vocab_filepaths)

face_det_sfd.py

@@ -0,0 +1,56 @@
+import sys
+import dlib
+import os
+import cv2
+import face_alignment
+import time
+
+from multiprocessing import Pool, Process, Queue
+
+
+def run(gpu, files):
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
+    fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D, flip_input=False, device='cuda')
+    print('gpu={},n_files={}'.format(gpu, len(files)))
+    tic = time.time()
+    count = 0
+    for (img_name, savename) in files:
+        I = cv2.imread(img_name)
+        points_list = fa.get_landmarks(I)
+        
+        with open(savename, 'w') as f:
+            if(points_list is not None):
+                for points in points_list:
+                    for (x, y) in points:
+                        f.write('({}, {})\t'.format(x, y))
+                    f.write('\n')
+
+        count += 1
+        if(count % 1000 == 0):
+            print('dst={},eta={}'.format(savename, (time.time()-tic)/(count) * (len(files) - count) / 3600.0))
+       
+
+if(__name__ == '__main__'):
+    with open('imgs.txt', 'r') as f:
+        data = [line.strip() for line in f.readlines()]
+    
+    data = [(name, name.replace('.jpg', '.txt')) for name in data]
+    for (_, dst) in data:
+        dir, _ = os.path.split(dst)
+        if(not os.path.exists(dir)):
+            os.makedirs(dir)
+       
+    processes = []
+    n_p = 3
+    gpus = ['1', '2', '3']
+    bs = len(data) // n_p
+    for i in range(n_p):
+        if(i == n_p - 1):
+            bs = len(data)
+        p = Process(target=run, args=(gpus[i],data[:bs],))
+        data = data[bs:]
+        p.start()
+        processes.append(p)
+    assert(len(data) == 0)
+    for p in processes:
+        p.join()

generate_phoneme_train_split.py

@@ -0,0 +1,50 @@
+import Loader
+import numpy as np
+import os
+
+from sklearn.model_selection import train_test_split
+
+TEST_FRAC = 0.2
+RANDOM_SEED = 42
+
+loader = Loader.GridLoader()
+# we'll leave out speaker 34 for testing
+video_paths = loader.load_video_paths(
+    verbose=True, fetch_all_paths=False,
+    verify_phonemes_length=True
+)
+
+new_video_paths = []
+for video_path in video_paths:
+    sentence = os.path.basename(video_path)
+    sentence, _ = os.path.splitext(sentence)
+    speaker_name = os.path.basename(os.path.dirname(video_path))
+    speaker_no = int(speaker_name[1:])
+    cache_key = (speaker_no, sentence)
+    new_video_paths.append(video_path)
+
+
+video_paths = new_video_paths
+train_paths, validate_paths, _, _ = train_test_split(
+    video_paths, video_paths,
+    test_size=TEST_FRAC, random_state=RANDOM_SEED
+)
+
+
+def get_speakers(filepaths):
+    return sorted(list(set([
+        os.path.basename(os.path.dirname(x)) for x in filepaths
+    ])))
+
+
+train_paths = sorted(train_paths)
+validate_paths = sorted(validate_paths)
+
+print(f'ALL_SPEAKERS {get_speakers(video_paths)}')
+print(f'TRAIN_PATHS: {len(train_paths)}')
+print(f'TRAIN_SPEAKERS: {get_speakers(train_paths)}')
+print(f'VALIDATE_PATHS: {len(validate_paths)}')
+print(f'VALIDATE_SPEAKERS: {get_speakers(validate_paths)}')
+
+open('data/phonemes_train.txt', 'w').write('\n'.join(train_paths))
+open('data/phonemes_val.txt', 'w').write('\n'.join(validate_paths))

generate_train_split.py

@@ -0,0 +1,68 @@
+import Loader
+import numpy as np
+import os
+
+from sklearn.model_selection import train_test_split
+
+TEST_FRAC = 0.2
+RANDOM_SEED = 42
+
+loader = Loader.GridLoader()
+# we'll leave out speaker 34 for testing
+video_paths = loader.load_video_paths(
+    verbose=True, fetch_all_paths=False,
+    excluded_speakers=[34]
+)
+
+# speaker-sentence pairs where lip extraction had problems
+bad_lip_pairs = {
+    (1, 'pbio7a'), (1, 'bwwuzn'), (7, 'bbir1s'), (1, 'prii9a'),
+    (2, 'pbwxzs'), (7, 'bbir2p'), (7, 'lbad1s'), (17, 'lbib9a'),
+    (1, 'bbizzn'), (7, 'lgws5s'), (3, 'lgbz9s'), (1, 'lrarzn'),
+    (3, 'pbiu6n'), (1, 'pbwx1s'), (3, 'bgit2n'), (3, 'lbij5s'),
+    (3, 'bramzn'), (1, 'lgbf8n'), (7, 'lrwe6p'), (1, 'brwg8p'),
+    (1, 'sbbh4p'), (3, 'swiu2n'), (7, 'lwak8p'), (7, 'sbatzn'),
+    (2, 'pwbd6s'), (7, 'pwii6n'), (9, 'bwaf6n'), (3, 'pgwy7s'),
+    (7, 'lwws1a'), (1, 'sran9s'), (7, 'bgam9s'), (3, 'bgbn9a'),
+    (3, 'prwq3a'), (7, 'sgio2p'), (4, 'lwiy3n'), (3, 'lbij7a'),
+    (1, 'brwa4p'), (2, 'pbib7p'), (3, 'lrbr3s')
+}
+
+new_video_paths = []
+for video_path in video_paths:
+    sentence = os.path.basename(video_path)
+    sentence, _ = os.path.splitext(sentence)
+    speaker_name = os.path.basename(os.path.dirname(video_path))
+    speaker_no = int(speaker_name[1:])
+    cache_key = (speaker_no, sentence)
+    # print(cache_key)
+
+    if cache_key in bad_lip_pairs:
+        print('SKIPPING', video_path)
+        continue
+
+    new_video_paths.append(video_path)
+
+
+video_paths = new_video_paths
+train_paths, validate_paths, _, _ = train_test_split(
+    video_paths, video_paths,
+    test_size=TEST_FRAC, random_state=RANDOM_SEED
+)
+
+
+def get_speakers(filepaths):
+    return set([os.path.basename(os.path.dirname(x)) for x in filepaths])
+
+
+train_paths = sorted(train_paths)
+validate_paths = sorted(validate_paths)
+
+print(f'ALL_SPEAKERS {get_speakers(video_paths)}')
+print(f'TRAIN_PATHS: {len(train_paths)}')
+print(f'TRAIN_SPEAKERS: {get_speakers(train_paths)}')
+print(f'VALIDATE_PATHS: {len(validate_paths)}')
+print(f'VALIDATE_SPEAKERS: {get_speakers(validate_paths)}')
+
+open('data/unseen_train.txt', 'w').write('\n'.join(train_paths))
+open('data/unseen_val.txt', 'w').write('\n'.join(validate_paths))

helpers.py

@@ -0,0 +1,50 @@
+import torch
+import numpy as np
+import string
+import shutil
+import os
+
+
+def kwargify(**kwargs):
+    return kwargs
+
+
+def show_lr(optimizer):
+    lr = []
+    for param_group in optimizer.param_groups:
+        lr += [param_group['lr']]
+
+    return np.array(lr).mean()
+
+
+def contains_nan_or_inf(tensor):
+    return torch.isnan(tensor).any() or torch.isinf(tensor).any()
+
+
+def map_phonemes(phonemes):
+    new_phonemes = []
+    charset = string.printable.strip()
+
+    for phoneme in phonemes:
+        if phoneme == ' ':
+            new_phonemes.append(phoneme)
+        else:
+            index = phonemes.index(phoneme) - 1
+            new_phonemes.append(charset[index])
+
+    return new_phonemes
+
+
+def empty_dir(directory):
+    for filename in os.listdir(directory):
+        file_path = os.path.join(directory, filename)
+
+        try:
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+            elif os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+        except Exception as e:
+            print('Failed to delete %s. Reason: %s' % (file_path, e))

main.py

@@ -0,0 +1,28 @@
+import os
+import resource
+
+from helpers import *
+from Trainer import Trainer
+
+rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
+resource.setrlimit(
+    resource.RLIMIT_NOFILE, (65536, rlimit[1])
+)
+
+if __name__ == '__main__':
+    opt = __import__('options')
+    os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu
+else:
+    import options as opt
+
+
+if __name__ == '__main__':
+    print("Loading options...")
+    trainer = Trainer()
+
+    if hasattr(opt, 'weights'):
+        trainer.load_weights(opt.weights)
+
+    torch.manual_seed(opt.random_seed)
+    torch.cuda.manual_seed_all(opt.random_seed)
+    trainer.train()

models/LipNet.py

@@ -0,0 +1,103 @@
+import torch 
+import torch.nn as nn
+import torch.nn.init as init
+import torch.nn.functional as F
+import math
+import numpy as np
+
+from helpers import *
+
+
+class LipNet(torch.nn.Module):
+    def __init__(
+        self, output_classes, dropout_p=0.5, pre_gru_repeats=0
+    ):
+        super(LipNet, self).__init__()
+        self.pre_gru_repeats = pre_gru_repeats
+
+        self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
+        self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+        
+        self.conv2 = nn.Conv3d(32, 64, (3, 5, 5), (1, 1, 1), (1, 2, 2))
+        self.pool2 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+        
+        self.conv3 = nn.Conv3d(64, 96, (3, 3, 3), (1, 1, 1), (1, 1, 1))     
+        self.pool3 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+        
+        self.gru1 = nn.GRU(96*4*8, 256, 1, bidirectional=True)
+        self.gru2 = nn.GRU(512, 256, 1, bidirectional=True)
+
+        self.output_classes = output_classes
+        self.FC = nn.Linear(512, output_classes+1)
+        self.dropout_p  = dropout_p
+
+        self.relu = nn.ReLU(inplace=True)
+        self.dropout = nn.Dropout(self.dropout_p)        
+        self.dropout3d = nn.Dropout3d(self.dropout_p)  
+        self._init()
+    
+    def _init(self):
+        init.kaiming_normal_(self.conv1.weight, nonlinearity='relu')
+        init.constant_(self.conv1.bias, 0)
+        
+        init.kaiming_normal_(self.conv2.weight, nonlinearity='relu')
+        init.constant_(self.conv2.bias, 0)
+        
+        init.kaiming_normal_(self.conv3.weight, nonlinearity='relu')
+        init.constant_(self.conv3.bias, 0)        
+        
+        init.kaiming_normal_(self.FC.weight, nonlinearity='sigmoid')
+        init.constant_(self.FC.bias, 0)
+        
+        for m in (self.gru1, self.gru2):
+            stdv = math.sqrt(2 / (96 * 3 * 6 + 256))
+            for i in range(0, 256 * 3, 256):
+                init.uniform_(m.weight_ih_l0[i: i + 256],
+                            -math.sqrt(3) * stdv, math.sqrt(3) * stdv)
+                init.orthogonal_(m.weight_hh_l0[i: i + 256])
+                init.constant_(m.bias_ih_l0[i: i + 256], 0)
+                init.uniform_(m.weight_ih_l0_reverse[i: i + 256],
+                            -math.sqrt(3) * stdv, math.sqrt(3) * stdv)
+                init.orthogonal_(m.weight_hh_l0_reverse[i: i + 256])
+                init.constant_(m.bias_ih_l0_reverse[i: i + 256], 0)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool1(x)
+        
+        x = self.conv2(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool2(x)
+        
+        x = self.conv3(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool3(x)
+        
+        # (B, C, T, H, W)->(T, B, C, H, W)
+        x = x.permute(2, 0, 1, 3, 4).contiguous()
+        # (B, C, T, H, W)->(T, B, C*H*W)
+        x = x.view(x.size(0), x.size(1), -1)
+        
+        self.gru1.flatten_parameters()
+        self.gru2.flatten_parameters()
+
+        if self.pre_gru_repeats > 1:
+            x = torch.repeat_interleave(
+                x, dim=0, repeats=self.pre_gru_repeats
+            )
+        
+        x, h = self.gru1(x)
+        x = self.dropout(x)
+        x, h = self.gru2(x)
+        x = self.dropout(x)
+                
+        x = self.FC(x)
+        x = x.permute(1, 0, 2).contiguous()
+        # assert not contains_nan_or_inf(x19)
+        return x
+        
+    

models/LipNetPlus.py

@@ -0,0 +1,185 @@
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+import torch.nn.functional as F
+from torch.nn import Transformer
+
+import math
+import numpy as np
+
+from helpers import *
+from torch import Tensor
+from models.PhonemeTransformer import (
+    PositionalEncoding, TokenEmbedding
+)
+
+
+class LipNetPlus(torch.nn.Module):
+    def __init__(
+        self, output_classes, dropout_p=0.0, pre_gru_repeats=0,
+        gru_output_size=512, embeds_size=256,
+        output_vocab_size=512, dropout_t=0.1,
+        src_vocab_size=4, num_encoder_layers: int = 3,
+        num_decoder_layers: int = 3, nhead: int = 8,
+        dim_feedforward: int = 512,
+    ):
+        super(LipNetPlus, self).__init__()
+        assert gru_output_size % 2 == 0
+        self.pre_gru_repeats = pre_gru_repeats
+        self.gru_out_size = gru_output_size
+        self.gru_hidden_size = gru_output_size // 2
+        self.embeds_size = embeds_size
+
+        self.output_vocab_size = output_vocab_size
+        self.gru_output_size = gru_output_size
+        self.dropout_t = dropout_t
+
+        self.conv1 = nn.Conv3d(3, 32, (3, 5, 5), (1, 2, 2), (1, 2, 2))
+        self.pool1 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.conv2 = nn.Conv3d(32, 64, (3, 5, 5), (1, 1, 1), (1, 2, 2))
+        self.pool2 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.conv3 = nn.Conv3d(64, 96, (3, 3, 3), (1, 1, 1), (1, 1, 1))
+        self.pool3 = nn.MaxPool3d((1, 2, 2), (1, 2, 2))
+
+        self.gru1 = nn.GRU(
+            96 * 4 * 8, self.gru_hidden_size, 1, bidirectional=True
+        )
+        self.gru2 = nn.GRU(
+            self.gru_output_size, self.gru_hidden_size, 1, bidirectional=True
+        )
+
+        self.output_classes = output_classes
+        self.FC = nn.Linear(self.gru_output_size, output_classes + 1)
+        self.dropout_p = dropout_p
+
+        self.relu = nn.ReLU(inplace=True)
+        self.dropout = nn.Dropout(self.dropout_p)
+        self.dropout3d = nn.Dropout3d(self.dropout_p)
+
+        self.src_tok_emb = TokenEmbedding(
+            src_vocab_size, self.embeds_size
+        )
+        self.tgt_tok_emb = TokenEmbedding(
+            output_vocab_size, self.embeds_size
+        )
+
+        self.embeds_layer = nn.Linear(
+            self.gru_output_size, self.embeds_size
+        )
+        self.transformer = Transformer(
+            d_model=self.embeds_size, nhead=nhead,
+            num_encoder_layers=num_encoder_layers,
+            num_decoder_layers=num_decoder_layers,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout_t
+        )
+        self.positional_encoding = PositionalEncoding(
+            self.embeds_size, dropout=self.dropout_t
+        )
+        self.generator = nn.Linear(
+            self.embeds_size, self.output_vocab_size
+        )
+        self._init()
+
+    def _init(self):
+        init.kaiming_normal_(self.conv1.weight, nonlinearity='relu')
+        init.constant_(self.conv1.bias, 0)
+
+        init.kaiming_normal_(self.conv2.weight, nonlinearity='relu')
+        init.constant_(self.conv2.bias, 0)
+
+        init.kaiming_normal_(self.conv3.weight, nonlinearity='relu')
+        init.constant_(self.conv3.bias, 0)
+
+        init.kaiming_normal_(self.FC.weight, nonlinearity='sigmoid')
+        init.constant_(self.FC.bias, 0)
+
+        transformer_components = [
+            self.transformer, self.generator,
+            self.positional_encoding
+        ]
+
+        for component in transformer_components:
+            for p in component.parameters():
+                if p.dim() > 1:
+                    nn.init.xavier_uniform_(p)
+
+        for m in (self.gru1, self.gru2):
+            stdv = math.sqrt(2 / (96 * 3 * 6 + 256))
+
+            for i in range(0, 256 * 3, 256):
+                init.uniform_(m.weight_ih_l0[i: i + 256],
+                              -math.sqrt(3) * stdv, math.sqrt(3) * stdv)
+                init.orthogonal_(m.weight_hh_l0[i: i + 256])
+                init.constant_(m.bias_ih_l0[i: i + 256], 0)
+                init.uniform_(m.weight_ih_l0_reverse[i: i + 256],
+                              -math.sqrt(3) * stdv, math.sqrt(3) * stdv)
+                init.orthogonal_(m.weight_hh_l0_reverse[i: i + 256])
+                init.constant_(m.bias_ih_l0_reverse[i: i + 256], 0)
+
+    def forward_gru(self, x):
+        x = self.conv1(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool1(x)
+
+        x = self.conv2(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool2(x)
+
+        x = self.conv3(x)
+        x = self.relu(x)
+        x = self.dropout3d(x)
+        x = self.pool3(x)
+
+        # (B, C, T, H, W)->(T, B, C, H, W)
+        x = x.permute(2, 0, 1, 3, 4).contiguous()
+        # (B, C, T, H, W)->(T, B, C*H*W)
+        x = x.view(x.size(0), x.size(1), -1)
+
+        self.gru1.flatten_parameters()
+        self.gru2.flatten_parameters()
+
+        if self.pre_gru_repeats > 1:
+            x = torch.repeat_interleave(
+                x, dim=0, repeats=self.pre_gru_repeats
+            )
+
+        x, h = self.gru1(x)
+        x = self.dropout(x)
+        x, h = self.gru2(x)
+        x = self.dropout(x)
+        return x
+
+    def predict_from_gru_out(self, x):
+        x = self.FC(x)
+        x = x.permute(1, 0, 2).contiguous()
+        # assert not contains_nan_or_inf(x19)
+        return x
+
+    def forward(self, x):
+        x = self.forward_gru(x)
+        x = self.predict_from_gru_out(x)
+        return x
+
+    def make_src_embeds(self, x):
+        x = self.embeds_layer(x)
+        x = self.relu(x)
+        return x
+
+    def seq_forward(
+        self, src_embeds: Tensor, trg: Tensor,
+        src_mask: Tensor, tgt_mask: Tensor, src_padding_mask: Tensor,
+        tgt_padding_mask: Tensor, memory_key_padding_mask: Tensor
+    ):
+        src_emb = self.positional_encoding(src_embeds)
+        tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))
+
+        outs = self.transformer(
+            src_emb, tgt_emb, src_mask, tgt_mask, None,
+            src_padding_mask, tgt_padding_mask, memory_key_padding_mask
+        )
+        return self.generator(outs)

models/PhonemeTransformer.py

@@ -0,0 +1,139 @@
+import torch
+import torch.nn as nn
+import math
+
+from torch import Tensor
+from torch.nn import Transformer
+
+# Define special symbols and indices
+UNK_IDX, PAD_IDX, BOS_IDX, EOS_IDX = 0, 1, 2, 3
+# Make sure the tokens are in order of their indices to properly
+# insert them in vocab
+
+UNK, PAD, BOS, EOS = "<unk>", "<pad>", "<bos>", "<eos>"
+SPECIAL_SYMBOLS = [UNK, PAD, BOS, EOS]
+
+
+# helper Module that adds positional encoding to the
+# token embedding to introduce a notion of word order.
+class PositionalEncoding(nn.Module):
+    def __init__(self, emb_size: int, dropout: float, maxlen: int = 5000):
+        super(PositionalEncoding, self).__init__()
+        den = torch.exp(
+            -torch.arange(0, emb_size, 2) *
+            math.log(10000) / emb_size
+        )
+
+        pos = torch.arange(0, maxlen).reshape(maxlen, 1)
+        pos_embedding = torch.zeros((maxlen, emb_size))
+        pos_embedding[:, 0::2] = torch.sin(pos * den)
+        pos_embedding[:, 1::2] = torch.cos(pos * den)
+        pos_embedding = pos_embedding.unsqueeze(-2)
+
+        self.dropout = nn.Dropout(dropout)
+        self.register_buffer('pos_embedding', pos_embedding)
+
+    def forward(self, token_embedding: Tensor):
+        return self.dropout(
+            token_embedding + self.pos_embedding[:token_embedding.size(0), :]
+        )
+
+
+# helper Module to convert tensor of input indices into
+# corresponding tensor of token embeddings
+class TokenEmbedding(nn.Module):
+    def __init__(self, vocab_size: int, emb_size):
+        super(TokenEmbedding, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, emb_size)
+        self.emb_size = emb_size
+
+    def forward(self, tokens: Tensor):
+        return self.embedding(tokens.long()) * math.sqrt(self.emb_size)
+
+
+# Seq2Seq Network
+class Seq2SeqTransformer(nn.Module):
+    def __init__(
+        self, src_vocab_size: int, tgt_vocab_size: int,
+        num_encoder_layers: int = 3,
+        num_decoder_layers: int = 3, emb_size: int = 512,
+        nhead: int = 8, dim_feedforward: int = 512,
+        dropout: float = 0.1
+    ):
+        super(Seq2SeqTransformer, self).__init__()
+        self.transformer = Transformer(
+            d_model=emb_size, nhead=nhead,
+            num_encoder_layers=num_encoder_layers,
+            num_decoder_layers=num_decoder_layers,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout
+        )
+
+        self.generator = nn.Linear(emb_size, tgt_vocab_size)
+        self.src_tok_emb = TokenEmbedding(src_vocab_size, emb_size)
+        self.tgt_tok_emb = TokenEmbedding(tgt_vocab_size, emb_size)
+        self.positional_encoding = PositionalEncoding(
+            emb_size, dropout=dropout
+        )
+        self._init()
+
+    def _init(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def forward(
+        self, src: Tensor, trg: Tensor,
+        src_mask: Tensor, tgt_mask: Tensor, src_padding_mask: Tensor,
+        tgt_padding_mask: Tensor, memory_key_padding_mask: Tensor
+    ):
+        # shape: [seq_len, batch_size, emb_size]
+        src_emb = self.positional_encoding(self.src_tok_emb(src))
+        tgt_emb = self.positional_encoding(self.tgt_tok_emb(trg))
+        outs = self.transformer(
+            src_emb, tgt_emb, src_mask, tgt_mask, None,
+            src_padding_mask, tgt_padding_mask, memory_key_padding_mask
+        )
+        return self.generator(outs)
+
+    def encode(self, src: Tensor, src_mask: Tensor):
+        return self.transformer.encoder(
+            self.positional_encoding(self.src_tok_emb(src)), src_mask
+        )
+
+    def decode(self, tgt: Tensor, memory: Tensor, tgt_mask: Tensor):
+        return self.transformer.decoder(
+            self.positional_encoding(self.tgt_tok_emb(tgt)),
+            memory, tgt_mask
+        )
+
+
+def generate_square_subsequent_mask(sz, device):
+    mask = (
+        torch.triu(torch.ones((sz, sz), device=device)) == 1
+    ).transpose(0, 1)
+    mask = mask.float().masked_fill(
+        mask == 0, float('-inf')
+    ).masked_fill(mask == 1, float(0.0))
+    return mask
+
+
+def create_tgt_mask(tgt, device):
+    tgt_seq_len = tgt.shape[0]
+    tgt_mask = generate_square_subsequent_mask(tgt_seq_len, device)
+    tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
+    return tgt_mask, tgt_padding_mask
+
+
+def create_mask(src, tgt, device):
+    src_seq_len = src.shape[0]
+    tgt_seq_len = tgt.shape[0]
+
+    tgt_mask = generate_square_subsequent_mask(tgt_seq_len, device)
+    src_mask = torch.zeros(
+        (src_seq_len, src_seq_len), device=device
+    ).type(torch.bool)
+
+    src_padding_mask = (src == PAD_IDX).transpose(0, 1)
+    tgt_padding_mask = (tgt == PAD_IDX).transpose(0, 1)
+    return src_mask, tgt_mask, src_padding_mask, tgt_padding_mask

move-videos.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Base directory
+base_dir=lip/GRID_lips
+
+# Loop through each speaker directory
+for i in {1..34}
+do
+    # Format the speaker directory, ensuring it is in the form s1, s2, ..., s34
+    speaker_dir=$(printf "s%d" $i)
+
+    # Source and destination paths
+    src="$base_dir/$speaker_dir/video/mpg_6000/*"
+    dest="$base_dir/$speaker_dir/"
+
+    vid_dir="$base_dir/$speaker_dir/video"
+    mpg_dir="$vid_dir/mpg_6000"
+
+    # Move the files and folders from source to destination
+    mv $src $dest
+    rmdir $mpg_dir
+    rmdir $vid_dir
+
+    # Echo the action
+    echo "Moved files from $src to $dest"
+done
+
+echo "All files moved successfully."

options.py

@@ -0,0 +1,40 @@
+gpu = '0'
+random_seed = 0
+data_type = 'phonemes'
+video_path = 'lip/'
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 75
+txt_padding = 200
+batch_size = 32
+base_lr = 8e-5
+num_workers = 12
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'overlap-phonemes'
+lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 1
+frame_doubling = False
+
+video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'GRID'
+
+phonemes_dir = 'lip/GRID_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+text_char_map = 'letters'
+char_map = 'phonemes'
+
+# weights = 'weights/I198000-L00048-W00018-C00005.pt'
+weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'

options_grid.py

@@ -0,0 +1,39 @@
+gpu = '0'
+random_seed = 0
+data_type = 'phonemes'
+video_path = 'lip/'
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 75
+txt_padding = 200
+batch_size = 16
+base_lr = 2e-5
+num_workers = 8
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'phonemes-nopre'
+lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 2
+frame_doubling = False
+
+video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'GRID'
+
+phonemes_dir = 'lip/GRID_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+text_char_map = 'letters'
+char_map = 'phonemes'
+
+# weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'

options_lrs2.py

@@ -0,0 +1,45 @@
+gpu = '0'
+random_seed = 0
+data_type = 'LRS2_CTC2'
+video_path = ''
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 100
+txt_padding = 200
+batch_size = 32
+base_lr = 8e-5
+num_workers = 8
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'phonemes-lrs2'
+lsr2_dir = '/home/milselarch/projects/SUTD/50-035/LRS2'
+# lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 1
+frame_doubling = False
+
+video_dir = f'{lsr2_dir}/lrs2_v1/main'
+# video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = f'{lsr2_dir}/lrs2_v1/mvlrs_v1/main'
+# alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = f'{lsr2_dir}/lrs2_v1/mvlrs_v1/main_images'
+# crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'LRS2'
+
+# phonemes_dir = 'lip/GRID_phonemes'
+phonemes_dir = f'{lsr2_dir}/lrs2_v1/mvlrs_v1/main_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+# 'lrs2_text' and 'cmu_phonemes
+text_char_map = 'lsr2_text'
+char_map = 'cmu_phonemes'
+
+# weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'

output_test.py

@@ -0,0 +1,24 @@
+import sys
+
+from dataset import GridDataset
+from Trainer import Trainer
+
+trainer = Trainer(write_logs=False)
+trainer.load_datasets()
+trainer.create_model()
+
+dataloader = trainer.dataset2dataloader(
+    trainer.train_dataset, num_workers=0
+)
+
+for batch in dataloader:
+    break
+
+vid = batch.get('vid').cuda()
+txt = batch.get('txt').cuda()
+vid_len = batch.get('vid_len').cuda()
+txt_len = batch.get('txt_len').cuda()
+y = trainer.net(vid)
+
+print(y)
+print('>>> ')

requirements.txt

@@ -0,0 +1,17 @@
+numpy~=1.24.4
+opencv-python~=4.8.0.76
+scipy~=1.10.1
+torch~=2.1.1
+editdistance~=0.6.2
+tensorboardX~=2.6.2.2
+scipy==1.10.1
+dlib==19.24.2
+tqdm==4.66.1
+face-alignment==1.4.1
+imageio==2.33.0
+pyyaml~=6.0.1
+scikit-learn==1.3.2
+huggingface-hub==0.19.4
+matplotlib==3.7.4
+pronouncing==0.2.0
+torchtext~=0.16.1

saved-runs/embeds-transformer-231207-0315/options.py

@@ -0,0 +1,40 @@
+gpu = '0'
+random_seed = 0
+data_type = 'phonemes'
+video_path = 'lip/'
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 80
+txt_padding = 200
+batch_size = 16
+base_lr = 2e-5
+num_workers = 8
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'phonemes-nopre'
+lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 1
+frame_doubling = False
+
+video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'GRID'
+
+phonemes_dir = 'lip/GRID_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+text_char_map = 'letters'
+char_map = 'phonemes'
+
+# weights = 'weights/I198000-L00048-W00018-C00005.pt'
+weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'

saved-runs/embeds-transformer-v2-231215-0040/options.py

@@ -0,0 +1,40 @@
+gpu = '0'
+random_seed = 0
+data_type = 'phonemes_overlap'
+video_path = 'lip/'
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 75
+txt_padding = 200
+batch_size = 32
+base_lr = 8e-5
+num_workers = 12
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'overlap-phonemes'
+lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 1
+frame_doubling = False
+
+video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'GRID'
+
+phonemes_dir = 'lip/GRID_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+text_char_map = 'letters'
+char_map = 'phonemes'
+
+# weights = 'weights/I198000-L00048-W00018-C00005.pt'
+# weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'

saved-runs/letters-231210-1505/options.py

@@ -0,0 +1,40 @@
+gpu = '0'
+random_seed = 0
+data_type = 'phonemes'
+video_path = 'lip/'
+train_list = f'data/{data_type}_train.txt'
+val_list = f'data/{data_type}_val.txt'
+anno_path = 'GRID_align_txt'
+vid_padding = 80
+txt_padding = 200
+batch_size = 16
+base_lr = 2e-5
+num_workers = 8
+max_epoch = 10000
+display = 10
+test_step = 1000
+save_prefix = f'weights/LipNet_{data_type}'
+is_optimize = True
+
+run_name = 'letters'
+lsr2_dir = '/media/milselarch/47FC4BC577667AAD/LRS2'
+pre_gru_repeats = 1
+frame_doubling = False
+
+video_dir = 'lip/GRID'
+audio_dir = 'lip/GRID_wavs'
+alignments_dir = 'lip/GRID_aligns'
+crop_images_dir = 'lip/GRID_lips'
+images_dir = crop_images_dir
+dataset = 'GRID'
+
+phonemes_dir = 'lip/GRID_phonemes'
+cache_videos = False
+use_lip_crops = True
+# what character set to have lipnet map to
+# options right now are 'letters' and 'phonemes'
+text_char_map = 'letters'
+char_map = 'letters'
+
+# weights = 'weights/I198000-L00048-W00018-C00005.pt'
+# weights = 'weights/phoneme-231201-0052/I198000-L00048-W00018-C00005.pt'