GLM-5 : Guide pour exécuter localement

Exécutez le nouveau modèle GLM-5 de Z.ai sur votre propre appareil local !

GLM-5 est le dernier modèle de raisonnement de Z.ai, offrant de meilleures performances en codage, agents et chat que GLM-4.7, et est conçu pour le raisonnement sur de longs contextes. Il améliore les performances sur des benchmarks tels que Humanity's Last Exam 50,4 % (+7,6 %), BrowseComp 75,9 % (+8,4 %) et Terminal-Bench-2.0 61,1 % (+28,3 %).

Le modèle complet de 744 milliards de paramètres (40B actifs) dispose d'une fenêtre de contexte 200K et a été pré-entraîné sur 28,5T de tokens. Le modèle complet GLM-5 nécessite 1,65 To d'espace disque, tandis que le GGUF dynamique 2 bits Unsloth réduit la taille à 241 Go (-85%), et dynamique 1 bit est 176 Go (-89 %) : GLM-5-GGUF

Tous les téléchargements utilisent Unsloth Dynamic 2.0 pour des performances de quantification SOTA - ainsi le 1 bit a des couches importantes mises à niveau en 8 ou 16 bits. Merci à Z.ai d'avoir fourni à Unsloth un accès dès le jour zéro.

⚙️ Guide d'utilisation

La quantification dynamique 2 bits UD-IQ2_XXS utilise 241 Go d'espace disque - cela peut tenir directement sur un Mac à mémoire unifiée 256 Go, et fonctionne également bien sur un carte 1x24 Go et 256 Go de RAM avec déchargement MoE. La quantification 1 bit tiendra sur 180 Go de RAM et le 8 bits nécessite 805 Go de RAM.

Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier du modèle quantifié que vous téléchargez. Si ce n'est pas le cas, llama.cpp peut toujours fonctionner via déchargement sur SSD/HDD, mais l'inférence sera plus lente.

Paramètres recommandés

Utilisez des paramètres distincts pour différents cas d'utilisation :

Paramètres par défaut (la plupart des tâches)	Vérifié par SWE Bench
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
max new tokens = 131072	max new tokens = 16384
repeat penalty = désactivé ou 1.0	repeat penalty = désactivé ou 1.0

• Min_P = 0.01 (la valeur par défaut de llama.cpp est 0,05)

• Fenêtre de contexte maximale : 202,752.

• Pour les tâches multi-tours agentiques (τ²-Bench et Terminal Bench 2), veuillez activer le mode Pensée Préservée.

Exécuter les tutoriels GLM-5 :

✨ Exécuter dans llama.cpp

1

Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de build ci-dessous. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement l'inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger les modèles, vous pouvez faire ce qui suit : (:IQ2_XXS) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). Ceci est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp pour enregistrer à un emplacement spécifique. N'oubliez pas que le modèle n'a qu'une longueur de contexte maximale de 200K.

Suivez ceci pour instruction générale cas d'utilisation :

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \
    --ctx-size 16384 \
    --flash-attn on \
    --temp 0.7 \
    --top-p 1.0 \
    --min-p 0.01

Suivez ceci pour appel d'outil cas d'utilisation :

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \
    --ctx-size 16384 \
    --flash-attn on \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01

3

Téléchargez le modèle via (après installation de pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-Q2_K_XL (quant dynamique 2 bits) ou d'autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d'utiliser notre quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer taille et précision. Si les téléchargements se bloquent, voir Hugging Face Hub, débogage XET

pip install -U huggingface_hub
hf download unsloth/GLM-5-GGUF \
    --local-dir unsloth/GLM-5-GGUF \
    --include "*UD-IQ2_XXS*" # Utilisez "*UD-TQ1_0*" pour le 1 bit dynamique

4

Vous pouvez modifier --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur de contexte, --n-gpu-layers 2 pour le déchargement GPU sur combien de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous avez uniquement de l'inférence CPU.

./llama.cpp/llama-cli \
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \
    --temp 1.0 \
    --top-p 0.95 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407

🦙 Service Llama-server & bibliothèque de complétion d'OpenAI

Pour déployer GLM-5 en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux, déployez le modèle via :

./llama.cpp/llama-server \
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \
    --alias "unsloth/GLM-5" \
    --prio 3 \
    --temp 1.0 \
    --top-p 0.95 \
    --ctx-size 16384 \
    --port 8001

Puis dans un nouveau terminal, après avoir fait pip install openai, faites :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/GLM-5",
    messages = [{"role": "user", "content": "Create a Snake game."},],
)
print(completion.choices[0].message.content)

Et vous obtiendrez l'exemple suivant d'un jeu Snake :

Voici un jeu Snake complet et jouable contenu dans un seul fichier HTML. Vous pouvez copier ce code, l'enregistrer comme fichier `.html` (par ex. `snake.html`) et l'ouvrir dans votre navigateur pour y jouer.

### Le code

```html
<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Jeu Snake Classique</title>
    <style>
        body {
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #222;
            color: white;
            font-family: Arial, sans-serif;
        }

        #gameCanvas {
            border: 2px solid #fff;
            background-color: #000;
        }

        h1 {
            margin-bottom: 10px;
        }

        #scoreBoard {
            font-size: 20px;
            margin-bottom: 10px;
        }

        #gameOverMenu {
            position: absolute;
            display: none;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            background: rgba(0, 0, 0, 0.85);
            padding: 20px;
            border-radius: 10px;
            border: 2px solid red;
        }

        button {
            margin-top: 15px;
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
            background-color: #4CAF50;
            color: white;
            border: none;
            border-radius: 5px;
        }
        
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>

    <h1>Jeu Snake</h1>
    <div id="scoreBoard">Score : 0</div>
    <canvas id="gameCanvas" width="400" height="400"></canvas>

    <div id="gameOverMenu">
        <h2 style="color: red; margin: 0;">Game Over !</h2>
        <p id="finalScore">Score final : 0</p>
        <button onclick="resetGame()">Rejouer</button>
    </div>

    <script>
        // Constantes du jeu
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        const scoreBoard = document.getElementById('scoreBoard');
        const gameOverMenu = document.getElementById('gameOverMenu');
        const finalScoreDisplay = document.getElementById('finalScore');

        const gridSize = 20; // Taille de chaque case
        const tileCount = canvas.width / gridSize; // Nombre de cases par ligne/colonne

        // Variables du jeu
        let dx = 0; // Vitesse horizontale
        let dy = 0; // Vitesse verticale
        let score = 0;
        let snake = [];
        let foodX, foodY;
        let gameInterval;
        let isGameRunning = false;

        // Initialiser le jeu
        function initGame() {
            snake = [
                {x: 10, y: 10}, 
                {x: 9, y: 10}, 
                {x: 8, y: 10}
            ];
            score = 0;
            scoreBoard.innerText = 'Score : ' + score;
            dx = 1; // Commence à se déplacer vers la droite immédiatement
            dy = 0;
            placeFood();
            isGameRunning = true;
            gameOverMenu.style.display = 'none';
            
            // Démarrer la boucle du jeu
            if (gameInterval) clearInterval(gameInterval);
            gameInterval = setInterval(gameLoop, 100); // Exécute la boucle toutes les 100ms
        }

        // Boucle principale du jeu
        function gameLoop() {
            if (!isGameRunning) return;

            moveSnake();
            if (checkGameOver()) {
                endGame();
                return;
            }
            checkFoodCollision();
            draw();
        }

        // Déplacer le snake
        function moveSnake() {
            // Créer une nouvelle tête selon la direction actuelle
            const head = {x: snake[0].x + dx, y: snake[0].y + dy};
            
            // Ajouter la nouvelle tête au début du tableau
            snake.unshift(head);

            // Supprimer la queue (dernier élément) sauf si la nourriture est mangée
            // Remarque : nous gérons la suppression de la queue dans checkFoodCollision
            snake.pop(); 
        }

        // Vérifier si le snake mange la nourriture
        function checkFoodCollision() {
            const head = snake[0];
            
            if (head.x === foodX && head.y === foodY) {
                // Agrandir le snake : ajouter un morceau de queue (dupliquer le dernier)
                snake.push({...snake[snake.length - 1]});
                score += 10;
                scoreBoard.innerText = 'Score : ' + score;
                placeFood();
            }
        }

        // Vérifier les collisions (murs ou soi-même)
        function checkGameOver() {
            const head = snake[0];

            // Collision avec les murs
            if (head.x < 0 || head.x >= tileCount || head.y < 0 || head.y >= tileCount) {
                return true;
            }

            // Collision avec soi-même (commencer la vérification à partir du 4ème segment car la tête ne peut pas toucher les 3 premiers)
            for (let i = 4; i < snake.length; i++) {
                if (head.x === snake[i].x && head.y === snake[i].y) {
                    return true;
                }
            }

            return false;
        }

        // Dessiner tout
        function draw() {
            // Effacer le canvas
            ctx.fillStyle = 'black';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // Dessiner la nourriture
            ctx.fillStyle = 'red';
            ctx.fillRect(foodX * gridSize, foodY * gridSize, gridSize - 2, gridSize - 2);

            // Dessiner le snake
            ctx.fillStyle = 'lime';
            for (let i = 0; i < snake.length; i++) {
                // Dessiner la tête légèrement différemment ou juste standard
                const part = snake[i];
                ctx.fillRect(part.x * gridSize, part.y * gridSize, gridSize - 2, gridSize - 2);
            }
        }

        // Placer la nourriture à une position aléatoire
        function placeFood() {
            foodX = Math.floor(Math.random() * tileCount);
            foodY = Math.floor(Math.random() * tileCount);

            // S'assurer que la nourriture n'apparaît pas sur le corps du snake
            for (let part of snake) {
                if (part.x === foodX && part.y === foodY) {
                    placeFood(); // Trouver récursivement un nouvel emplacement
                    return;
                }
            }
        }

        // Logique de fin de jeu
        function endGame() {
            isGameRunning = false;
            clearInterval(gameInterval);
            finalScoreDisplay.innerText = 'Score final : ' + score;
            gameOverMenu.style.display = 'flex';
        }

        // Logique de réinitialisation du jeu
        function resetGame() {
            initGame();
        }

        // Contrôles clavier
        document.addEventListener('keydown', (e) => {
            // Empêcher l'inversion de direction (ne peut pas aller à gauche si on va à droite)
            switch(e.key) {
                case 'ArrowUp':
                    if (dy !== 1) { dx = 0; dy = -1; }
                    break;
                case 'ArrowDown':
                    if (dy !== -1) { dx = 0; dy = 1; }
                    break;
                case 'ArrowLeft':
                    if (dx !== 1) { dx = -1; dy = 0; }
                    break;
                case 'ArrowRight':
                    if (dx !== -1) { dx = 1; dy = 0; }
                    break;
                case ' ':
                    if (!isGameRunning && gameOverMenu.style.display !== 'flex') {
                        initGame();
                    }
                    break;
            }
        });

        // Démarrer le jeu au chargement
        initGame();
    </script>
</body>
</html>
```

### Comment jouer
1.  **Copiez le code** ci-dessus.
2.  Créez un nouveau fichier sur votre ordinateur nommé `snake.html`.
3.  **Collez le code** dans ce fichier et enregistrez-le.
4.  **Double-cliquez sur `snake.html`** pour l'ouvrir dans votre navigateur.

### Contrôles
*   **Flèches** : Aller en haut, bas, gauche, droite.
*   **Barre d'espace** : Démarre le jeu (s'il n'a pas encore commencé).
*   **Bouton Rejouer** : Apparaît lorsque vous vous écrasez pour redémarrer la partie.

### Fonctionnalités de cette version
*   **Mouvement sur grille** : Sensation rétro classique.
*   **Suivi du score** : Mise à jour en temps réel.
*   **Écran Game Over** : Affiche votre score final et vous permet de redémarrer facilement.
*   **Détection de collision** : Met fin à la partie si vous heurtez les murs ou vous-même.
*   **Sécurité contre la collision avec soi-même** : Le code empêche le serpent de se manger accidentellement immédiatement après avoir mangé de la nourriture en raison de la logique de "saut de queue" couramment trouvée dans les tutoriels simples.

💻 Déploiement vLLM

Vous pouvez désormais servir la version FP8 du modèle de Z.ai via vLLM. Vous avez besoin de 860 Go de VRAM ou plus, donc 8xH200 (141x8 = 1128 Go) est au minimum recommandé. 8xB200 fonctionne bien. Tout d'abord, installez vllm nightly :

uv pip install --upgrade --force-reinstall vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly/cu130
uv pip install --upgrade --force-reinstall git+https://github.com/huggingface/transformers.git
uv pip install --force-reinstall numba

Pour désactiver le KV Cache FP8 (réduit l'utilisation mémoire de 50 %), retirez --kv-cache-dtype fp8

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
vllm serve unsloth/GLM-5-FP8 \
    --served-model-name unsloth/GLM-5-FP8 \ \
    --kv-cache-dtype fp8 \
    --tensor-parallel-size 8 \
    --tool-call-parser glm47 \
    --reasoning-parser glm45 \
    --enable-auto-tool-choice \
    --dtype bfloat16 \
    --seed 3407 \
    --max-model-len 200000 \
    --gpu-memory-utilization 0.93 \
    --max_num_batched_tokens 4096 \
    --speculative-config.method mtp \
    --speculative-config.num_speculative_tokens 1 \
    --port 8001

Vous pouvez ensuite appeler le modèle servi via l'API OpenAI :

from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # ou AsyncOpenAI
    api_key = openai_api_key,
    base_url = openai_api_base,
)

🔨Appel d'outils avec GLM 5

Voir Tool Calling Guide pour plus de détails sur la façon de faire des appels d'outils. Dans un nouveau terminal (si vous utilisez tmux, utilisez CTRL+B+D), nous créons quelques outils comme additionner 2 nombres, exécuter du code Python, exécuter des fonctions Linux et bien plus :

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Il y a bien longtemps dans une galaxie lointaine, très lointaine...",
        "Il y avait 2 amis qui aimaient les paresseux et le code...",
        "Le monde était en train de disparaître parce que chaque paresseux avait évolué pour avoir une intelligence surhumaine...",
        "À l'insu d'un ami, l'autre a accidentellement codé un programme pour faire évoluer les paresseux...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Impossible d'exécuter les commandes 'rm, sudo, dd, chmod' car elles sont dangereuses"
        print(msg); return msg
    print(f"Exécution de la commande terminal `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Échec de la commande : {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Ajouter deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multiplier deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Soustraire deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Écrit une histoire aléatoire.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Effectuer des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appeler un interpréteur Python avec du code Python qui sera exécuté.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Le code Python à exécuter",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Nous utilisons ensuite les fonctions ci-dessous (copier-coller et exécuter) qui analyseront automatiquement les appels de fonctions et appelleront le point de terminaison OpenAI pour n'importe quel modèle :

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = -1,
    min_p = 0.01,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Using model = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Current messages = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages

Après avoir lancé GLM 5 via llama-server comme dans GLM-5 ou voir Tool Calling Guide pour plus de détails, nous pouvons alors effectuer certains appels d'outils.

📊 Références de performance

Vous pouvez voir ci-dessous d'autres benchmarks sous forme de tableau :

Benchmark	GLM-5	GLM-4.7	DeepSeek-V3.2	Kimi K2.5	Claude Opus 4.5	Gemini 3 Pro	GPT-5.2 (xhigh)
HLE	30.5	24.8	25.1	31.5	28.4	37.2	35.4
HLE (avec outils)	50.4	42.8	40.8	51.8	43.4*	45.8*	45.5*
AIME 2026 I	92.7	92.9	92.7	92.5	93.3	90.6	-
HMMT Nov. 2025	96.9	93.5	90.2	91.1	91.7	93.0	97.1
IMOAnswerBench	82.5	82.0	78.3	81.8	78.5	83.3	86.3
GPQA-Diamond	86.0	85.7	82.4	87.6	87.0	91.9	92.4
SWE-bench Vérifié	77.8	73.8	73.1	76.8	80.9	76.2	80.0
SWE-bench Multilingue	73.3	66.7	70.2	73.0	77.5	65.0	72.0
Terminal-Bench 2.0 (Terminus 2)	56,2 / 60,7 †	41.0	39.3	50.8	59.3	54.2	54.0
Terminal-Bench 2.0 (Claude Code)	56,2 / 61,1 †	32.8	46.4	-	57.9	-	-
CyberGym	43.2	23.5	17.3	41.3	50.6	39.9	-
BrowseComp	62.0	52.0	51.4	60.6	37.0	37.8	-
BrowseComp (avec gestion du contexte)	75.9	67.5	67.6	74.9	67.8	59.2	65.8
BrowseComp-Zh	72.7	66.6	65.0	62.3	62.4	66.8	76.1
τ²-Bench	89.7	87.4	85.3	80.2	91.6	90.7	85.5
MCP-Atlas (ensemble public)	67.8	52.0	62.2	63.8	65.2	66.6	68.0
Tool-Decathlon	38.0	23.8	35.2	27.8	43.5	36.4	46.3
Vending Bench 2	$4,432.12	$2,376.82	$1,034.00	$1,198.46	$4,967.06	$5,478.16	$3,591.33