Cleanup: Remove unnecessary files and update .gitignore

.gitignore

@@ -84,3 +84,11 @@ logs/
  
 # Hugging Face cache directory
 .hf_cache/
+
+# Ignore Python cache and virtual environment directories
+__pycache__/
+.venv/
+*.pyc
+*~
+.env
+.DS_Store

README.md

@@ -396,3 +396,39 @@ Ready for production with:
 Successfully transformed from broken Gradio app to production-ready AI backend service.
 
 For detailed conversion documentation, see [`CONVERSION_COMPLETE.md`](CONVERSION_COMPLETE.md).
+
+# Gemma 3n GGUF FastAPI Backend (Hugging Face Space)
+
+This Space provides an OpenAI-compatible chat API for Gemma 3n GGUF models, powered by FastAPI.
+
+**Note:** On Hugging Face Spaces, the backend runs in `DEMO_MODE` (no model loaded) for demonstration and endpoint testing. For real inference, run locally with a GGUF model and llama-cpp-python.
+
+## Endpoints
+
+- `/health` — Health check
+- `/v1/chat/completions` — OpenAI-style chat completions (returns demo response)
+- `/train/start` — Start a (demo) training job
+- `/train/status/{job_id}` — Check training job status
+- `/train/logs/{job_id}` — Get training logs
+
+## Usage
+
+1. **Clone this repo** or create a Hugging Face Space (type: FastAPI).
+2. All dependencies are in `requirements.txt`.
+3. The Space will start in demo mode (no model download required).
+
+## Local Inference (with GGUF)
+
+To run with a real model locally:
+
+1. Download a Gemma 3n GGUF model (e.g. from https://huggingface.co/unsloth/gemma-3n-E4B-it-GGUF).
+2. Set `AI_MODEL` to the local path or repo.
+3. Unset `DEMO_MODE`.
+4. Run:
+   ```bash
+   pip install -r requirements.txt
+   uvicorn gemma_gguf_backend:app --host 0.0.0.0 --port 8000
+   ```
+
+## License
+Apache 2.0

gemma_gguf_backend.py

@@ -9,6 +9,11 @@ import logging
 import time
 from contextlib import asynccontextmanager
 from typing import List, Dict, Any, Optional
+import uuid
+import sys
+import subprocess
+import threading
+from pathlib import Path
 
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import JSONResponse
@@ -97,6 +102,12 @@ async def lifespan(app: FastAPI):
     """Application lifespan manager for startup and shutdown events"""
     global llm
     logger.info("🚀 Starting Gemma 3n GGUF Backend Service...")
+    if os.environ.get("DEMO_MODE", "").strip() not in ("", "0", "false", "False"):
+        logger.info("🧪 DEMO_MODE enabled: skipping model load")
+        llm = None
+        yield
+        logger.info("🔄 Shutting down Gemma 3n Backend Service (demo mode)...")
+        return
     
     if not llama_cpp_available:
         logger.error("❌ llama-cpp-python is not available. Please install with: pip install llama-cpp-python")
@@ -262,6 +273,177 @@ async def create_chat_completion(
         logger.error(f"Error in chat completion: {e}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
+# -----------------------------
+# Training Job Management (Unsloth)
+# -----------------------------
+
+# Jobs are tracked in-memory; logs and artifacts are written to disk
+TRAIN_JOBS: Dict[str, Dict[str, Any]] = {}
+TRAIN_DIR = Path(os.environ.get("TRAIN_DIR", "./training_runs")).resolve()
+TRAIN_DIR.mkdir(parents=True, exist_ok=True)
+
+def _start_training_subprocess(job_id: str, args: Dict[str, Any]) -> subprocess.Popen[Any]:
+    """Spawn a subprocess to run the Unsloth fine-tuning script."""
+    logs_dir = TRAIN_DIR / job_id
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    log_file = open(logs_dir / "train.log", "w", encoding="utf-8")
+
+    # Build absolute script path to avoid module/package resolution issues
+    script_path = (Path(__file__).parent / "training" / "train_gemma_unsloth.py").resolve()
+    python_exec = sys.executable
+
+    cmd = [
+        python_exec,
+        str(script_path),
+        "--job-id", job_id,
+        "--output-dir", str(logs_dir),
+    ]
+
+    # Optional user-specified args
+    def _extend(k: str, v: Any):
+        if v is None:
+            return
+        if isinstance(v, bool):
+            cmd.extend([f"--{k}"] if v else [])
+        else:
+            cmd.extend([f"--{k}", str(v)])
+
+    _extend("dataset", args.get("dataset"))
+    _extend("text-field", args.get("text_field"))
+    _extend("prompt-field", args.get("prompt_field"))
+    _extend("response-field", args.get("response_field"))
+    _extend("max-steps", args.get("max_steps"))
+    _extend("epochs", args.get("epochs"))
+    _extend("lr", args.get("lr"))
+    _extend("batch-size", args.get("batch_size"))
+    _extend("gradient-accumulation", args.get("gradient_accumulation"))
+    _extend("lora-r", args.get("lora_r"))
+    _extend("lora-alpha", args.get("lora_alpha"))
+    _extend("cutoff-len", args.get("cutoff_len"))
+    _extend("model-id", args.get("model_id"))
+    _extend("use-bf16", args.get("use_bf16"))
+    _extend("use-fp16", args.get("use_fp16"))
+    _extend("seed", args.get("seed"))
+    _extend("dry-run", args.get("dry_run"))
+
+    logger.info(f"🧵 Starting training subprocess for job {job_id}: {' '.join(cmd)}")
+    logger.info(f"🐍 Using interpreter: {python_exec}")
+    proc = subprocess.Popen(cmd, stdout=log_file, stderr=subprocess.STDOUT, cwd=str(Path(__file__).parent))
+    return proc
+
+def _watch_process(job_id: str, proc: subprocess.Popen[Any]):
+    """Monitor a training process and update job state on exit."""
+    return_code = proc.wait()
+    status = "completed" if return_code == 0 else "failed"
+    TRAIN_JOBS[job_id]["status"] = status
+    TRAIN_JOBS[job_id]["return_code"] = return_code
+    TRAIN_JOBS[job_id]["ended_at"] = int(time.time())
+    logger.info(f"🏁 Training job {job_id} finished with status={status}, code={return_code}")
+
+class StartTrainingRequest(BaseModel):
+    dataset: str = Field(..., description="HF dataset name or path to local JSONL/JSON file")
+    model_id: Optional[str] = Field(default="unsloth/gemma-3n-E4B-it", description="Base model for training (HF Transformers format)")
+    text_field: Optional[str] = Field(default=None, description="Single text field name (SFT)")
+    prompt_field: Optional[str] = Field(default=None, description="Prompt/instruction field (chat data)")
+    response_field: Optional[str] = Field(default=None, description="Response/output field (chat data)")
+    max_steps: Optional[int] = Field(default=None)
+    epochs: Optional[int] = Field(default=1)
+    lr: Optional[float] = Field(default=2e-4)
+    batch_size: Optional[int] = Field(default=1)
+    gradient_accumulation: Optional[int] = Field(default=8)
+    lora_r: Optional[int] = Field(default=16)
+    lora_alpha: Optional[int] = Field(default=32)
+    cutoff_len: Optional[int] = Field(default=4096)
+    use_bf16: Optional[bool] = Field(default=True)
+    use_fp16: Optional[bool] = Field(default=False)
+    seed: Optional[int] = Field(default=42)
+    dry_run: Optional[bool] = Field(default=False, description="Write DONE and exit without running (for CI/macOS)")
+
+class StartTrainingResponse(BaseModel):
+    job_id: str
+    status: str
+    output_dir: str
+
+class TrainStatusResponse(BaseModel):
+    job_id: str
+    status: str
+    created_at: int
+    started_at: Optional[int] = None
+    ended_at: Optional[int] = None
+    output_dir: Optional[str] = None
+    return_code: Optional[int] = None
+
+@app.post("/train/start", response_model=StartTrainingResponse)
+def start_training(req: StartTrainingRequest):
+    """Start a background Unsloth fine-tuning job. Returns a job_id to poll."""
+    job_id = uuid.uuid4().hex[:12]
+    now = int(time.time())
+    output_dir = str((TRAIN_DIR / job_id).resolve())
+    TRAIN_JOBS[job_id] = {
+        "status": "starting",
+        "created_at": now,
+        "started_at": now,
+        "args": req.model_dump(),
+        "output_dir": output_dir,
+    }
+
+    try:
+        proc = _start_training_subprocess(job_id, req.model_dump())
+        TRAIN_JOBS[job_id]["status"] = "running"
+        TRAIN_JOBS[job_id]["pid"] = proc.pid
+        watcher = threading.Thread(target=_watch_process, args=(job_id, proc), daemon=True)
+        watcher.start()
+        return StartTrainingResponse(job_id=job_id, status="running", output_dir=output_dir)
+    except Exception as e:
+        logger.exception("Failed to start training job")
+        TRAIN_JOBS[job_id]["status"] = "failed_to_start"
+        raise HTTPException(status_code=500, detail=f"Failed to start training: {e}")
+
+@app.get("/train/status/{job_id}", response_model=TrainStatusResponse)
+def train_status(job_id: str):
+    job = TRAIN_JOBS.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return TrainStatusResponse(
+        job_id=job_id,
+        status=job.get("status", "unknown"),
+        created_at=job.get("created_at", 0),
+        started_at=job.get("started_at"),
+        ended_at=job.get("ended_at"),
+        output_dir=job.get("output_dir"),
+        return_code=job.get("return_code"),
+    )
+
+@app.get("/train/logs/{job_id}")
+def train_logs(job_id: str, tail: int = 200):
+    job = TRAIN_JOBS.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    log_path = Path(job["output_dir"]) / "train.log"
+    if not log_path.exists():
+        return {"job_id": job_id, "logs": "(no logs yet)"}
+    try:
+        with open(log_path, "r", encoding="utf-8", errors="ignore") as f:
+            lines = f.readlines()[-tail:]
+        return {"job_id": job_id, "logs": "".join(lines)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to read logs: {e}")
+
+@app.post("/train/stop/{job_id}")
+def train_stop(job_id: str):
+    job = TRAIN_JOBS.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    pid = job.get("pid")
+    if not pid:
+        raise HTTPException(status_code=400, detail="Job does not have an active PID")
+    try:
+        os.kill(pid, 15)  # SIGTERM
+        job["status"] = "stopping"
+        return {"job_id": job_id, "status": "stopping"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to stop job: {e}")
+
 # Main entry point
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -1,14 +1,12 @@
-gradio>=5.41.0
-huggingface_hub>=0.34.0
+fastapi
+uvicorn[standard]
+pydantic
+llama-cpp-python
+# Training dependencies for CCUF/Unsloth
+unsloth>=2024.7.0
+datasets>=2.20.0
+trl>=0.9.6
+peft>=0.11.1
 transformers>=4.36.0
 torch>=2.0.0
-Pillow>=10.0.0
 accelerate>=0.24.0
-requests>=2.31.0
-protobuf>=3.20.0
-# llama-cpp-python for GGUF model support (Gemma 3n)
-llama-cpp-python>=0.3.14
-# NOTE: GGUF models like 'unsloth/gemma-3n-E4B-it-GGUF' can be loaded directly from HuggingFace
-fastapi>=0.100.0
-uvicorn[standard]>=0.23.0
-pydantic>=2.0.0

sample_data/train.jsonl

@@ -0,0 +1,2 @@
+{"prompt": "Hello! Introduce yourself.", "response": "I'm a helpful assistant built on Gemma 3n."}
+{"prompt": "Give me a fun fact.", "response": "Honey never spoils; archaeologists found edible honey in ancient Egyptian tombs."}

space.yaml

@@ -0,0 +1,5 @@
+sdk: fastapi
+python_version: 3.10
+app_file: gemma_gguf_backend.py
+env:
+  - DEMO_MODE=1

test_training_api.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+Minimal integration test for training endpoints.
+"""
+import time
+import json
+import requests
+
+BASE = "http://localhost:8001"
+
+print("1) Start a training job")
+resp = requests.post(f"{BASE}/train/start", json={
+    "dataset": "./sample_data/train.jsonl",
+    "model_id": "unsloth/gemma-3n-E4B-it",
+    "prompt_field": "prompt",
+    "response_field": "response",
+    "epochs": 1,
+    "batch_size": 1,
+    "gradient_accumulation": 8,
+    "use_bf16": True,
+    "dry_run": True
+})
+print(resp.status_code, resp.text)
+resp.raise_for_status()
+job = resp.json()
+job_id = job["job_id"]
+print("job_id=", job_id)
+
+print("2) Poll status (10s)")
+for _ in range(10):
+    s = requests.get(f"{BASE}/train/status/{job_id}")
+    print(s.status_code, json.dumps(s.json(), indent=2))
+    time.sleep(1)
+
+print("3) Done")

training/train_gemma_unsloth.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+Unsloth fine-tuning runner for Gemma-3n-E4B-it.
+- Trains a LoRA adapter on top of HF Transformers-format base model (not GGUF).
+- Output: PEFT adapter that can later be merged/exported to GGUF separately if desired.
+
+This is a minimal, production-friendly CLI so the API server can spawn it as a subprocess.
+"""
+import argparse
+import os
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict
+
+# Lazy imports to keep API light
+
+def _import_training_libs() -> Dict[str, Any]:
+    """Try to import Unsloth fast path; if unavailable, fall back to Transformers+PEFT.
+
+    Returns a dict with keys:
+      mode: "unsloth" | "hf"
+      load_dataset, SFTTrainer, SFTConfig
+      If mode=="unsloth": FastLanguageModel, AutoTokenizer
+      If mode=="hf": AutoTokenizer, AutoModelForCausalLM, get_peft_model, LoraConfig, torch
+    """
+    # Avoid heavy optional deps on macOS (no xformers/bitsandbytes)
+    os.environ.setdefault("UNSLOTH_DISABLE_XFORMERS", "1")
+    os.environ.setdefault("UNSLOTH_DISABLE_BITSANDBYTES", "1")
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    try:
+        from unsloth import FastLanguageModel
+        from transformers import AutoTokenizer
+        return {
+            "mode": "unsloth",
+            "load_dataset": load_dataset,
+            "SFTTrainer": SFTTrainer,
+            "SFTConfig": SFTConfig,
+            "FastLanguageModel": FastLanguageModel,
+            "AutoTokenizer": AutoTokenizer,
+        }
+    except Exception:
+        # Fallback: pure HF + PEFT (CPU / MPS friendly)
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        from peft import get_peft_model, LoraConfig
+        import torch
+        return {
+            "mode": "hf",
+            "load_dataset": load_dataset,
+            "SFTTrainer": SFTTrainer,
+            "SFTConfig": SFTConfig,
+            "AutoTokenizer": AutoTokenizer,
+            "AutoModelForCausalLM": AutoModelForCausalLM,
+            "get_peft_model": get_peft_model,
+            "LoraConfig": LoraConfig,
+            "torch": torch,
+        }
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument("--job-id", required=True)
+    p.add_argument("--output-dir", required=True)
+    p.add_argument("--dataset", required=True, help="HF dataset path or local JSON/JSONL file")
+    p.add_argument("--text-field", dest="text_field", default=None)
+    p.add_argument("--prompt-field", dest="prompt_field", default=None)
+    p.add_argument("--response-field", dest="response_field", default=None)
+    p.add_argument("--model-id", dest="model_id", default="unsloth/gemma-3n-E4B-it")
+    p.add_argument("--epochs", type=int, default=1)
+    p.add_argument("--max-steps", dest="max_steps", type=int, default=None)
+    p.add_argument("--lr", type=float, default=2e-4)
+    p.add_argument("--batch-size", dest="batch_size", type=int, default=1)
+    p.add_argument("--gradient-accumulation", dest="gradient_accumulation", type=int, default=8)
+    p.add_argument("--lora-r", dest="lora_r", type=int, default=16)
+    p.add_argument("--lora-alpha", dest="lora_alpha", type=int, default=32)
+    p.add_argument("--cutoff-len", dest="cutoff_len", type=int, default=4096)
+    p.add_argument("--use-bf16", dest="use_bf16", action="store_true")
+    p.add_argument("--use-fp16", dest="use_fp16", action="store_true")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--dry-run", dest="dry_run", action="store_true", help="Write DONE and exit without training (for CI)")
+    return p.parse_args()
+
+
+def _is_local_path(s: str) -> bool:
+    return os.path.exists(s)
+
+
+def _load_dataset(load_dataset: Any, path: str) -> Any:
+    if _is_local_path(path):
+        # Infer extension
+        if path.endswith(".jsonl") or path.endswith(".jsonl.gz"):
+            return load_dataset("json", data_files=path, split="train")
+        elif path.endswith(".json"):
+            return load_dataset("json", data_files=path, split="train")
+        else:
+            raise ValueError("Unsupported local dataset format. Use JSON or JSONL.")
+    else:
+        return load_dataset(path, split="train")
+
+
+def main():
+    args = parse_args()
+    start = time.time()
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / "meta.json").write_text(json.dumps({
+        "job_id": args.job_id,
+        "model_id": args.model_id,
+        "dataset": args.dataset,
+        "created_at": int(start),
+    }, indent=2))
+
+    if args.dry_run:
+        (out_dir / "DONE").write_text("dry_run")
+        print("[train] Dry run complete. DONE written.")
+        return
+
+    # Training imports (supports Unsloth fast path and HF fallback)
+    libs: Dict[str, Any] = _import_training_libs()
+    load_dataset = libs["load_dataset"]
+    SFTTrainer = libs["SFTTrainer"]
+    SFTConfig = libs["SFTConfig"]
+
+    # Environment for stability on T4 etc per Unsloth guidance
+    os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+    print(f"[train] Loading base model: {args.model_id}")
+    if libs["mode"] == "unsloth":
+        FastLanguageModel = libs["FastLanguageModel"]
+        AutoTokenizer = libs["AutoTokenizer"]
+        model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=args.model_id,
+            max_seq_length=args.cutoff_len,
+            # Avoid bitsandbytes/xformers
+            load_in_4bit=False,
+            dtype=None,
+            use_gradient_checkpointing="unsloth",
+        )
+        # Prepare LoRA via Unsloth helper
+        print("[train] Attaching LoRA adapter (Unsloth)")
+        model = FastLanguageModel.get_peft_model(
+            model,
+            r=args.lora_r,
+            lora_alpha=args.lora_alpha,
+            lora_dropout=0,
+            bias="none",
+            target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+            use_rslora=True,
+            loftq_config=None,
+        )
+    else:
+        # HF + PEFT fallback (CPU / MPS)
+        AutoTokenizer = libs["AutoTokenizer"]
+        AutoModelForCausalLM = libs["AutoModelForCausalLM"]
+        get_peft_model = libs["get_peft_model"]
+        LoraConfig = libs["LoraConfig"]
+        torch = libs["torch"]
+
+        tokenizer = AutoTokenizer.from_pretrained(args.model_id, use_fast=True, trust_remote_code=True)
+        # Prefer MPS on Apple Silicon if available
+        use_mps = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+        torch_dtype = torch.float16 if (args.use_fp16 or args.use_bf16) and not use_mps else torch.float32
+        model = AutoModelForCausalLM.from_pretrained(
+            args.model_id,
+            torch_dtype=torch_dtype,
+            trust_remote_code=True,
+        )
+        if use_mps:
+            model.to("mps")
+        print("[train] Attaching LoRA adapter (HF/PEFT)")
+        lora_config = LoraConfig(
+            r=args.lora_r,
+            lora_alpha=args.lora_alpha,
+            target_modules=["q_proj","k_proj","v_proj","o_proj","gate_proj","up_proj","down_proj"],
+            lora_dropout=0.0,
+            bias="none",
+            task_type="CAUSAL_LM",
+        )
+        model = get_peft_model(model, lora_config)
+
+    # Load dataset
+    print(f"[train] Loading dataset: {args.dataset}")
+    ds = _load_dataset(load_dataset, args.dataset)
+
+    # Build formatting
+    text_field = args.text_field
+    prompt_field = args.prompt_field
+    response_field = args.response_field
+
+    if text_field:
+        # Simple SFT: single text field
+        def format_row(ex):
+            return ex[text_field]
+    elif prompt_field and response_field:
+        # Chat data: prompt + response
+        def format_row(ex):
+            return f"<start_of_turn>user\n{ex[prompt_field]}<end_of_turn>\n<start_of_turn>model\n{ex[response_field]}<end_of_turn>\n"
+    else:
+        raise ValueError("Provide either --text-field or both --prompt-field and --response-field")
+
+    def map_fn(ex):
+        return {"text": format_row(ex)}
+
+    ds = ds.map(map_fn, remove_columns=[c for c in ds.column_names if c != "text"])
+
+    # Trainer
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=ds,
+        max_seq_length=args.cutoff_len,
+        dataset_text_field="text",
+        packing=True,
+        args=SFTConfig(
+            output_dir=str(out_dir / "hf"),
+            per_device_train_batch_size=args.batch_size,
+            gradient_accumulation_steps=args.gradient_accumulation,
+            learning_rate=args.lr,
+            num_train_epochs=args.epochs,
+            max_steps=args.max_steps if args.max_steps else -1,
+            logging_steps=10,
+            save_steps=200,
+            save_total_limit=2,
+            bf16=args.use_bf16,
+            fp16=args.use_fp16,
+            seed=args.seed,
+            report_to=[],
+        ),
+    )
+
+    print("[train] Starting training...")
+    trainer.train()
+    print("[train] Saving adapter...")
+    adapter_path = out_dir / "adapter"
+    adapter_path.mkdir(parents=True, exist_ok=True)
+    # Save adapter-only weights if PEFT; Unsloth path is also PEFT-compatible
+    try:
+        model.save_pretrained(str(adapter_path))
+    except Exception:
+        # Fallback: save full model (large); unlikely on LoRA
+        try:
+            model.base_model.save_pretrained(str(adapter_path))  # type: ignore[attr-defined]
+        except Exception:
+            pass
+    tokenizer.save_pretrained(str(adapter_path))
+
+    # Write done file
+    (out_dir / "DONE").write_text("ok")
+    elapsed = time.time() - start
+    print(f"[train] Finished in {elapsed:.1f}s. Artifacts at: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

training_runs/c6fdb7b0a765/meta.json

@@ -0,0 +1,6 @@
+{
+  "job_id": "c6fdb7b0a765",
+  "model_id": "unsloth/gemma-3n-E4B-it",
+  "dataset": "./sample_data/train.jsonl",
+  "created_at": 1754620412
+}

training_runs/devlocal/DONE

@@ -0,0 +1 @@
+dry_run

training_runs/devlocal/meta.json

@@ -0,0 +1,6 @@
+{
+  "job_id": "devlocal",
+  "model_id": "unsloth/gemma-3n-E4B-it",
+  "dataset": "/Users/congnguyen/DevRepo/firstAI/sample_data/train.jsonl",
+  "created_at": 1754620844
+}