Added new files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text
+generated_motion.gif filter=lfs diff=lfs merge=lfs -text
+walker.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.ipynb_checkpoints

RunVLA.py

@@ -0,0 +1,219 @@
+import torch
+import numpy as np
+import re
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import torch.nn.functional as F
+from PIL import Image  # Used for loading image files
+from IPython.display import display, Image as IPyImage  # Used for displaying GIFs inside Jupyter notebooks
+
+# Import classes required for the Vision-Language model
+from transformers import Qwen2_5_VLForConditionalGeneration, AutoProcessor
+from safetensors.torch import load_file
+from rvq_model.rvq_model import MotionRVQ_VAE
+
+# ==========================================
+# 1. Configuration
+# ==========================================
+IMAGE_PATH = "walker.jpeg"
+PROMPT_TEXT = "Describe the image and generate a matching physical motion."
+QWEN_PATH = "./"
+RVQ_WEIGHTS = "./rvq_model/motion_rvq_weights.safetensors"
+OUTPUT_GIF = "generated_motion.gif"
+
+torch.manual_seed(42)
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# ==========================================
+# 2. Load Qwen-VL (Brain & Eyes)
+# ==========================================
+print("Loading Qwen2.5-VL model and processor...")
+
+# The processor includes both the tokenizer and image preprocessing pipeline
+processor = AutoProcessor.from_pretrained(QWEN_PATH)
+
+llm_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+    QWEN_PATH,
+    torch_dtype=torch.bfloat16,
+    device_map="auto"  # Automatically places the model on the GPU if available
+)
+llm_model.eval()
+
+# ==========================================
+# 3. Load the RVQ model (Body)
+# ==========================================
+print("Loading RVQ decoder...")
+
+rvq_model = MotionRVQ_VAE().to(device)
+state_dict = load_file(RVQ_WEIGHTS, device=str(device))
+rvq_model.load_state_dict(state_dict)
+rvq_model.eval()
+
+mean = np.load('./rvq_model/Mean.npy')
+std = np.load('./rvq_model/Std.npy')
+
+# ==========================================
+# 4. Process image and generate a response
+# ==========================================
+print(f"\nAI instruction: '{PROMPT_TEXT}' with image '{IMAGE_PATH}'")
+
+# Load the image using PIL
+image = Image.open(IMAGE_PATH).convert("RGB")
+
+# Vision-language prompt structure
+messages = [
+    {
+        "role": "system",
+        "content": "You are an embodied AI. You reason about your physical state and output precise motor actions inside <move></move> tags."
+    },
+    {
+        "role": "user",
+        "content": [
+            {"type": "image"},  # Placeholder indicating where the image will be inserted
+            {"type": "text", "text": PROMPT_TEXT}
+        ]
+    }
+]
+
+# Prepare both text and image inputs using the processor
+text_prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+inputs = processor(
+    text=[text_prompt],
+    images=[image],
+    padding=True,
+    return_tensors="pt"
+).to(device)
+
+print("Observing image, reasoning, and generating motion...")
+
+with torch.no_grad():
+    outputs = llm_model.generate(
+        **inputs,
+        max_new_tokens=1024,
+        temperature=0.5,  # Lower temperature improves RVQ token consistency
+        do_sample=True,
+    )
+
+# Extract only the generated portion, excluding the original prompt
+generated_ids = [
+    output_ids[len(input_ids):] for input_ids, output_ids in zip(inputs.input_ids, outputs)
+]
+response = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+response = response.replace("<|im_end|>", "").strip()
+
+print("\n=== QWEN RESPONSE ===")
+print(response)
+print("=====================\n")
+
+# ==========================================
+# 5. Extract and parse motion tokens
+# ==========================================
+move_blocks = re.findall(r'<move>(.*?)</move>', response, re.DOTALL)
+
+if not move_blocks:
+    print("ERROR: Qwen did not generate any motion tokens.")
+    exit()
+
+all_tokens = []
+for block in move_blocks:
+    tokens = re.findall(r'<m_(\d+)_(\d+)>', block)
+    all_tokens.extend(tokens)
+
+if not all_tokens:
+    print("ERROR: No valid tokens were found inside the <move> tags.")
+    exit()
+
+num_frames = len(all_tokens) // 4
+token_matrix = np.zeros((4, num_frames), dtype=np.int64)
+
+for i in range(num_frames):
+    for lvl in range(4):
+        token_idx = i * 4 + lvl
+        if token_idx < len(all_tokens):
+            parsed_lvl, val = all_tokens[token_idx]
+            token_matrix[lvl, i] = int(val)
+
+token_tensor = torch.tensor(token_matrix, device=device).unsqueeze(0)
+
+# ==========================================
+# 6. Decode tokens into 3D motion
+# ==========================================
+print(f"Decoding {num_frames} token frames into 3D motion...")
+
+with torch.no_grad():
+    z_q = 0
+    for lvl in range(4):
+        indices = token_tensor[:, lvl, :]
+        quantizer = rvq_model.rvq.quantizers[lvl]
+        level_z_q = F.embedding(indices, quantizer.embedding)
+        level_z_q = level_z_q.permute(0, 2, 1)
+        z_q = z_q + level_z_q
+    reconstructed_motion = rvq_model.decoder(z_q)
+
+recon_data = reconstructed_motion.squeeze(0).permute(1, 0).cpu().numpy()
+recon_data = (recon_data * std) + mean
+T_frames = recon_data.shape[0]
+
+# ==========================================
+# 7. Save and visualize the generated motion
+# ==========================================
+def get_3d_joints(data_263):
+    frames = data_263.shape[0]
+    joints = np.zeros((frames, 22, 3))
+    for i in range(frames):
+        root_y = data_263[i, 3]
+        joints[i, 0] = [0, root_y, 0]
+        local_positions = data_263[i, 4:67].reshape(21, 3)
+        joints[i, 1:] = local_positions + [0, root_y, 0]
+    return joints
+
+joints_recon = get_3d_joints(recon_data)
+
+kinematic_tree = [
+    [0, 1, 4, 7, 10],
+    [0, 2, 5, 8, 11],
+    [0, 3, 6, 9, 12, 15],
+    [9, 13, 16, 18, 20],
+    [9, 14, 17, 19, 21]
+]
+
+fig = plt.figure(figsize=(6, 6))
+ax = fig.add_subplot(111, projection='3d')
+
+def update(frame):
+    ax.clear()
+    ax.set_title(f"QWEN-VLA GENERATED MOTION\nFrame: {frame}/{T_frames}")
+    ax.set_xlim(-1, 1)
+    ax.set_ylim(-1, 1)
+    ax.set_zlim(0, 2)
+    ax.view_init(elev=10., azim=-90)
+    ax.axis('off')
+
+    for chain in kinematic_tree:
+        ax.plot(
+            joints_recon[frame, chain, 0],
+            joints_recon[frame, chain, 2],
+            joints_recon[frame, chain, 1],
+            linewidth=3,
+            marker='o',
+            markersize=4,
+            color='red'
+        )
+
+print("Generating GIF file...")
+
+ani = animation.FuncAnimation(
+    fig,
+    update,
+    frames=T_frames,
+    interval=50,
+    repeat=True
+)
+
+# Save using PillowWriter (works well in Jupyter and does not require FFmpeg)
+ani.save(OUTPUT_GIF, writer='pillow', fps=20)
+
+# Close the figure to prevent an empty plot from appearing in notebook output
+plt.close(fig)
+
+print(f"Animation saved to file: {OUTPUT_GIF}")

TrainVLA.py

@@ -0,0 +1,103 @@
+from unsloth import FastVisionModel
+import torch
+from datasets import load_dataset
+from transformers import TrainingArguments, TrainerCallback
+from trl import SFTTrainer, DataCollatorForCompletionOnlyLM
+
+# Callback to stop training when certain loss was achieved
+class StopAtLossCallback(TrainerCallback):
+    def __init__(self, threshold):
+        self.threshold = threshold
+
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        if logs and "loss" in logs:
+            current_loss = logs["loss"]
+            if current_loss <= self.threshold:
+                print(f"\n[!] Target loss achieved. Training stopped.")
+                control.should_training_stop = True
+
+# Model config
+max_seq_length = 2048
+model_name = "Qwen/Qwen2.5-VL-3B-Instruct"
+
+model, processor = FastVisionModel.from_pretrained(
+    model_name = model_name,
+    max_seq_length = max_seq_length,
+    dtype = torch.bfloat16, 
+    load_in_4bit = False, # Jeśli braknie VRAM, zmień na True!
+)
+
+tokenizer = processor.tokenizer
+
+# Add new tokens
+new_tokens = ["<move>", "</move>"]
+for lvl in range(4):
+    for val in range(1024):
+        new_tokens.append(f"<m_{lvl}_{val}>")
+
+tokenizer.add_special_tokens({'additional_special_tokens': new_tokens})
+model.resize_token_embeddings(len(tokenizer))
+
+# Train everything except vision
+for name, param in model.named_parameters():
+    # Jeśli w nazwie warstwy jest 'visual' lub 'vision' - nie trenujemy jej
+    if "visual" in name or "vision" in name:
+        param.requires_grad = False
+    else:
+        param.requires_grad = True
+
+model.gradient_checkpointing_enable()
+
+# Dataset
+dataset = load_dataset("json", data_files="la_dataset.jsonl", split="train")
+
+def format_qwen_chat(examples):
+    texts = []
+    for instruction, output in zip(examples["instruction"], examples["output"]):
+        chat = [
+            {"role": "system", "content": "You are an embodied AI. You reason about your physical state and output precise motor actions inside <move></move> tags."},
+            {"role": "user", "content": instruction},
+            {"role": "assistant", "content": output}
+        ]
+        text = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=False)
+        texts.append(text)
+    return { "text" : texts }
+
+dataset = dataset.map(format_qwen_chat, batched = True)
+
+response_template = "<|im_start|>assistant\n"
+collator = DataCollatorForCompletionOnlyLM(response_template=response_template, tokenizer=tokenizer)
+
+# Training
+trainer = SFTTrainer(
+    model = model,
+    tokenizer = tokenizer,
+    train_dataset = dataset,
+    dataset_text_field = "text",
+    max_seq_length = max_seq_length,
+    dataset_num_proc = 2,
+    data_collator = collator,
+    callbacks=[StopAtLossCallback(threshold=1.0)], # target loss
+    args = TrainingArguments(
+        per_device_train_batch_size = 2,
+        gradient_accumulation_steps = 8,
+        warmup_steps = 100, 
+        num_train_epochs = 100,
+        learning_rate = 2e-5,
+        fp16 = not torch.cuda.is_bf16_supported(),
+        bf16 = torch.cuda.is_bf16_supported(),
+        logging_steps = 10,
+        output_dir = "outputs_qwen_vl_fft",
+        optim = "adamw_8bit",
+        save_strategy="no", 
+        save_total_limit=1,
+    ),
+)
+
+trainer.train()
+
+new_save_path = "Qwen2_5_VL_VLA_Final"
+model.save_pretrained(new_save_path)
+processor.save_pretrained(new_save_path)
+
+print(f"Training done, model saved to {new_save_path}.")

chat_template.jinja

@@ -0,0 +1,7 @@
+{% set image_count = namespace(value=0) %}{% set video_count = namespace(value=0) %}{% for message in messages %}{% if loop.first and message['role'] != 'system' %}<|im_start|>system
+You are a helpful assistant.<|im_end|>
+{% endif %}<|im_start|>{{ message['role'] }}
+{% if message['content'] is string %}{{ message['content'] }}<|im_end|>
+{% else %}{% for content in message['content'] %}{% if content['type'] == 'image' or 'image' in content or 'image_url' in content %}{% set image_count.value = image_count.value + 1 %}{% if add_vision_id %}Picture {{ image_count.value }}: {% endif %}<|vision_start|><|image_pad|><|vision_end|>{% elif content['type'] == 'video' or 'video' in content %}{% set video_count.value = video_count.value + 1 %}{% if add_vision_id %}Video {{ video_count.value }}: {% endif %}<|vision_start|><|video_pad|><|vision_end|>{% elif 'text' in content %}{{ content['text'] }}{% endif %}{% endfor %}<|im_end|>
+{% endif %}{% endfor %}{% if add_generation_prompt %}<|im_start|>assistant
+{% endif %}

config.json

@@ -0,0 +1,116 @@
+{
+  "architectures": [
+    "Qwen2_5_VLForConditionalGeneration"
+  ],
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "eos_token_id": 151645,
+  "image_token_id": 151655,
+  "model_name": "unsloth/Qwen2.5-VL-3B-Instruct",
+  "model_type": "qwen2_5_vl",
+  "pad_token_id": 151654,
+  "text_config": {
+    "attention_dropout": 0.0,
+    "bos_token_id": 151643,
+    "dtype": "bfloat16",
+    "eos_token_id": 151645,
+    "hidden_act": "silu",
+    "hidden_size": 2048,
+    "initializer_range": 0.02,
+    "intermediate_size": 11008,
+    "layer_types": [
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention",
+      "full_attention"
+    ],
+    "max_position_embeddings": 128000,
+    "max_window_layers": 70,
+    "model_type": "qwen2_5_vl_text",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 36,
+    "num_key_value_heads": 2,
+    "pad_token_id": 151654,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "mrope_section": [
+        16,
+        24,
+        24
+      ],
+      "rope_theta": 1000000.0,
+      "rope_type": "default",
+      "type": "default"
+    },
+    "sliding_window": null,
+    "use_cache": true,
+    "use_sliding_window": false,
+    "vocab_size": 155763
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.5.0",
+  "unsloth_fixed": true,
+  "unsloth_version": "2026.6.1",
+  "use_cache": false,
+  "video_token_id": 151656,
+  "vision_config": {
+    "depth": 32,
+    "dtype": "bfloat16",
+    "fullatt_block_indexes": [
+      7,
+      15,
+      23,
+      31
+    ],
+    "hidden_act": "silu",
+    "hidden_size": 1280,
+    "in_channels": 3,
+    "in_chans": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 3420,
+    "model_type": "qwen2_5_vl",
+    "num_heads": 16,
+    "out_hidden_size": 2048,
+    "patch_size": 14,
+    "spatial_merge_size": 2,
+    "spatial_patch_size": 14,
+    "temporal_patch_size": 2,
+    "tokens_per_second": 2,
+    "window_size": 112
+  },
+  "vision_end_token_id": 151653,
+  "vision_start_token_id": 151652,
+  "vision_token_id": 151654
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "do_sample": true,
+  "eos_token_id": [
+    151645,
+    151645,
+    151643
+  ],
+  "max_length": 128000,
+  "pad_token_id": 151654,
+  "repetition_penalty": 1.05,
+  "temperature": 1e-06,
+  "transformers_version": "5.5.0"
+}

model.safetensors

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

processor_config.json

@@ -0,0 +1,59 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_processor_type": "Qwen2VLImageProcessor",
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "merge_size": 2,
+    "patch_size": 14,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 12845056,
+      "shortest_edge": 3136
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen2_5_VLProcessor",
+  "video_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": false,
+    "image_mean": [
+      0.48145466,
+      0.4578275,
+      0.40821073
+    ],
+    "image_std": [
+      0.26862954,
+      0.26130258,
+      0.27577711
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 14,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 12845056,
+      "shortest_edge": 3136
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen2VLVideoProcessor"
+  }
+}

rvq_model/Mean.npy

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

rvq_model/Std.npy

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

rvq_model/motion_rvq_weights.safetensors

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

rvq_model/rvq_model.py

@@ -0,0 +1,140 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class EMAVectorQuantizer(nn.Module):
+    def __init__(
+        self,
+        num_embeddings=512,
+        embedding_dim=256,
+        commitment_cost=0.25,
+        decay=0.99,
+        epsilon=1e-5,
+    ):
+        super().__init__()
+        self.num_embeddings = num_embeddings
+        self.embedding_dim = embedding_dim
+        self.commitment_cost = commitment_cost
+        self.decay = decay
+        self.epsilon = epsilon
+
+        embed = torch.randn(num_embeddings, embedding_dim)
+        self.register_buffer("embedding", embed)
+        self.register_buffer("cluster_size", torch.zeros(num_embeddings))
+        self.register_buffer("ema_w", embed.clone())
+
+    def forward(self, z):
+        z = z.permute(0, 2, 1).contiguous()
+        z_flattened = z.view(-1, self.embedding_dim)
+
+        distances = (
+            torch.sum(z_flattened**2, dim=1, keepdim=True)
+            + torch.sum(self.embedding**2, dim=1)
+            - 2 * torch.matmul(z_flattened, self.embedding.t())
+        )
+
+        min_encoding_indices = torch.argmin(distances, dim=1)
+        z_q = F.embedding(min_encoding_indices, self.embedding)
+
+        if self.training:
+            encodings = F.one_hot(min_encoding_indices, self.num_embeddings).float()
+            self.cluster_size.data.mul_(self.decay).add_(encodings.sum(0), alpha=1 - self.decay)
+
+            n = self.cluster_size.sum()
+            cluster_size = (self.cluster_size + self.epsilon) / (
+                n + self.num_embeddings * self.epsilon
+            ) * n
+
+            dw = torch.matmul(encodings.t(), z_flattened)
+            self.ema_w.data.mul_(self.decay).add_(dw, alpha=1 - self.decay)
+            self.embedding.data.copy_(self.ema_w / cluster_size.unsqueeze(1))
+
+        loss = self.commitment_cost * F.mse_loss(z_q.detach(), z_flattened)
+        z_q = z_flattened + (z_q - z_flattened).detach()
+        z_q = z_q.view(z.shape).permute(0, 2, 1).contiguous()
+
+        return z_q, min_encoding_indices.view(z.shape[0], z.shape[1]), loss
+
+
+class RVQ(nn.Module):
+    def __init__(self, num_levels=3, num_embeddings=512, embedding_dim=256):
+        super().__init__()
+        self.num_levels = num_levels
+        self.quantizers = nn.ModuleList(
+            [EMAVectorQuantizer(num_embeddings, embedding_dim) for _ in range(num_levels)]
+        )
+
+    def forward(self, z):
+        quantized_out = 0
+        residual = z
+        all_indices = []
+        total_loss = 0
+
+        for quantizer in self.quantizers:
+            z_q, indices, loss = quantizer(residual)
+            quantized_out = quantized_out + z_q
+            residual = residual - z_q
+            all_indices.append(indices)
+            total_loss += loss
+
+        return quantized_out, torch.stack(all_indices, dim=1), total_loss
+
+
+class ResBlock1D(nn.Module):
+    def __init__(self, channels):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv1d(channels, channels, kernel_size=3, padding=1),
+            nn.LeakyReLU(0.2, inplace=True),
+            nn.Conv1d(channels, channels, kernel_size=3, padding=1),
+        )
+
+    def forward(self, x):
+        return x + self.net(x)
+
+
+class MotionEncoder(nn.Module):
+    def __init__(self, in_channels=263, latent_dim=512):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv1d(in_channels, 512, kernel_size=3, padding=1),
+            nn.LeakyReLU(0.2, inplace=True),
+            ResBlock1D(512),
+            ResBlock1D(512),
+            ResBlock1D(512),
+            nn.Conv1d(512, latent_dim, kernel_size=8, stride=4, padding=2),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class MotionDecoder(nn.Module):
+    def __init__(self, latent_dim=512, out_channels=263):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.ConvTranspose1d(latent_dim, 512, kernel_size=8, stride=4, padding=2),
+            nn.LeakyReLU(0.2, inplace=True),
+            ResBlock1D(512),
+            ResBlock1D(512),
+            ResBlock1D(512),
+            nn.Conv1d(512, out_channels, kernel_size=3, padding=1),
+        )
+
+    def forward(self, z_q):
+        return self.net(z_q)
+
+
+class MotionRVQ_VAE(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.encoder = MotionEncoder(in_channels=263, latent_dim=512)
+        self.rvq = RVQ(num_levels=4, num_embeddings=1024, embedding_dim=512)
+        self.decoder = MotionDecoder(latent_dim=512, out_channels=263)
+
+    def forward(self, x):
+        z = self.encoder(x)
+        z_q, token_indices, commitment_loss = self.rvq(z)
+        x_recon = self.decoder(z_q)
+        return x_recon, token_indices, commitment_loss

tokenizer.json

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