> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/language-models/minimax-m27.md).

# MiniMax M2.7 (229B MoE Coding)

{% hint style="info" %}
**स्थिति (अप्रैल 2026):** MiniMax M2.7 को HuggingFace पर प्रकाशित किया गया था **9 अप्रैल 2026** MiniMaxAI द्वारा और पहुँचा **तीन हफ्तों में 496K डाउनलोड** — अपनाने के आधार पर, हमारे अप्रैल रिफ्रेश का सबसे बड़ा open-weight रिलीज़। वेट्स यहाँ उपलब्ध हैं [huggingface.co/MiniMaxAI/MiniMax-M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7) के अंतर्गत **कस्टम MiniMax लाइसेंस** (`लाइसेंस: अन्य`). यह है **नहीं** Apache/MIT — पढ़ें [LICENSE](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) किसी भी व्यावसायिक तैनाती से पहले।
{% endhint %}

{% hint style="warning" %}
**सुधार:** हमारे मॉडल इंडेक्स के पहले के संस्करणों में M2.7 को एक स्वामित्व वाला, केवल-API मॉडल बताया गया था। 9 अप्रैल 2026 तक यह गलत था — वेट्स सार्वजनिक हैं। यह मार्गदर्शिका उस सूचीकरण को बदलती है।
{% endhint %}

MiniMax M2.7 एक **229-बिलियन-पैरामीटर Mixture-of-Experts** मॉडल (256 experts, टोकन प्रति 8 सक्रिय) है और MiniMax के M2 परिवार की नवीनतम प्रविष्टि है — एक श्रृंखला जो आधारित है **स्व-उत्क्रांतिकारी / RL-संचालित पोस्ट-ट्रेनिंग** और **एजेंटिक कोडिंग** वर्कलोड्स पर। 2.7 रिलीज़ MiniMax के होस्टेड कोडिंग एजेंट का सार्वजनिक, स्वयं-होस्ट करने योग्य समकक्ष है और MiniMax इसे एजेंटिक बेंचमार्क्स पर Claude Sonnet 4.5 के बराबर या उससे बेहतर तथा उनमें से कुछ पर Claude Opus 4.6 के स्तर के करीब बताता है।

रोचक आर्किटेक्चरल विवरण है **Interleaved Thinking** (M2.1 में प्रस्तुत और 2.5/2.7 के माध्यम से परिष्कृत): मॉडल `<think>` मल्टी-टर्न टूल कॉल्स के दौरान सामान्य जनरेशन के साथ reasoning blocks को बारी-बारी से चलाता है, इसलिए function-call round-trips के पार chain of thought बनी रहती है, बजाय इसके कि हर टर्न पर उसे छोड़ दिया जाए। यही इसे लंबे-होराइजन एजेंटों के लिए दिलचस्प बनाता है — reasoning trace हर बार `tool_use` सीमा पर रीसेट नहीं होता।

Clore.ai उपयोगकर्ताओं के लिए व्यावहारिक खबर यह है कि M2.7 आधिकारिक repo पर एक **FP8 (float8\_e4m3fn) चेकपॉइंट** के साथ आता है। इससे एकल-नोड डिप्लॉयमेंट की पहुंच **4× H100 80GB** या **2× H200 141GB** — H200 octets या 16-GPU रैक की आवश्यकता नहीं। यदि आप [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) और अपनी agent stack में अलग bias profile के साथ दूसरा open-weight मॉडल चाहते हैं, तो इसे साथ में जोड़ने के लिए यही मॉडल है।

### मुख्य विनिर्देश

| गुण                  | मान                                                                                                                                                      |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| कुल पैरामीटर         | 229B (MoE, 256 experts)                                                                                                                                  |
| Experts per Token    | 256 में से 8                                                                                                                                             |
| सक्रिय पैरामीटर      | **आधिकारिक रूप से प्रकाशित नहीं** — model card देखें। M2 परिवार ऐतिहासिक रूप से \~10B सक्रिय रहा है; सार्वजनिक रूप से उद्धृत करने से पहले सत्यापित करें। |
| Hidden size / Layers | 3,072 / 62                                                                                                                                               |
| अटेंशन               | 48 heads, 8 KV (GQA)                                                                                                                                     |
| संदर्भ विंडो         | 204,800 टोकन (200K)                                                                                                                                      |
| टेंसर प्रकार         | F32, BF16, F8\_E4M3                                                                                                                                      |
| MTP                  | Multi-Token Prediction सक्षम (3 MTP modules)                                                                                                             |
| लाइसेंस              | **कस्टम MiniMax — डिफ़ॉल्ट रूप से गैर-व्यावसायिक**                                                                                                       |
| रिलीज़ तिथि          | 9 अप्रैल 2026                                                                                                                                            |
| HF डाउनलोड (3 हफ्ते) | \~496K                                                                                                                                                   |
| अनुशंसित सैंपलिंग    | `temperature=1.0`, `top_p=0.95`, `top_k=40`                                                                                                              |
| मुख्य टूलिंग         | vLLM, SGLang, Transformers, KTransformers, MLX-LM                                                                                                        |

### MiniMax M2.7 क्यों?

* **229B पर ओपन वेट्स** — सबसे बड़ा "वास्तविक" open-weight कोडिंग मॉडल, जो FP8 में अभी भी एक ही 4×H100 नोड पर फिट हो जाता है
* **Interleaved Thinking** — `<think>` ब्लॉक्स टूल-कॉल टर्न्स के पार बने रहते हैं, जो SWE-शैली के एजेंटों के लिए सचमुच उपयोगी है
* **बहुभाषी कोडिंग पर ध्यान** — MiniMax सिर्फ Python नहीं, बल्कि Rust, Go, Java, Kotlin, Swift, और TypeScript में भी मजबूत प्रदर्शन का दावा करता है
* **अपनाने का संकेत** — तीन हफ्तों में 496K डाउनलोड अप्रैल 2026 के किसी भी open-weight रिलीज़ के लिए, जिसे हमने ट्रैक किया है, समुदाय द्वारा सबसे मजबूत अपनाना है
* **MTP समर्थन** — Multi-Token Prediction modules के माध्यम से speculative decoding अंतर्निहित है, जिससे H100/H200 पर वास्तविक throughput मिलता है
* **होस्टेड फ़ॉलबैक** — यदि आपका workload एकल नोड से बड़ा हो जाता है, तो MiniMax का होस्टेड endpoint उपलब्ध है; architecture तय करते समय आपको चुनना नहीं पड़ता

***

## आवश्यकताएँ

{% hint style="warning" %}
**Clore.ai marketplace पर multi-GPU 80GB-class rigs सूचीबद्ध नहीं हैं।** आज सूचीबद्ध सबसे बड़े boxes 4× RTX PRO 6000 Blackwell (प्रत्येक 96GB, कुल 380GB) और 8–11× RTX 5090 (प्रत्येक 32GB) हैं। A100 / H200 / B200 क्षमता [bare metal](https://clore.ai/bare-metal) के रूप में अनुरोध पर बेची जाती है। देखें [GPU मूल्य और उपलब्धता](/guides/guides_v2-hi/getting-started/pricing.md) किसी deployment का आकार तय करने से पहले।
{% endhint %}

{% hint style="warning" %}
**229B, फिर भी 229B ही है।** BF16 वेट्स लगभग 460GB हैं। FP8 चेकपॉइंट लगभग आधा — \~230GB — है, और यही इसे एकल-नोड डिप्लॉयमेंट के लिए संभव बनाता है। INT4 community quants इसे \~120GB से नीचे ले आते हैं, लेकिन वे आधिकारिक रूप से समर्थित नहीं हैं।
{% endhint %}

| घटक      | शौकिया (INT4 GGUF, offload)      | अनुशंसित (FP8 single-node)        | पूर्ण BF16                   |
| -------- | -------------------------------- | --------------------------------- | ---------------------------- |
| GPU VRAM | 24–48GB GPU + 128GB+ RAM offload | 4× H100 80GB **या** 2× H200 141GB | 8× H100 80GB / 4× H200 141GB |
| कुल VRAM | \~48GB GPU + offload             | 320GB / 282GB                     | 640GB / 564GB                |
| RAM      | 128GB                            | 256GB                             | 512GB                        |
| डिस्क    | 200GB NVMe                       | 400GB NVMe                        | 600GB NVMe                   |
| CUDA     | 12.8+                            | 12.8+                             | 12.8+                        |

**Clore.ai की पसंद:** पर FP8 चेकपॉइंट **2× H200** सबसे साफ़ deployment target है — न्यूनतम tensor-parallel splits, कम NCCL hops, और 200K context के लिए गणना बस काम करती है। **4× H100** यदि H200 स्टॉक कम हो, तो यह सस्ता विकल्प है।

***

## विकल्प A — Ollama / GGUF (Quantized)

{% hint style="warning" %}
**केवल सामुदायिक quants।** MiniMax M2.7 के लिए आधिकारिक GGUF वेट्स प्रकाशित नहीं करता। सामुदायिक Q4/Q5 builds आमतौर पर रिलीज़ के 1–2 हफ्ते बाद दिखाई देते हैं — खोजें [huggingface.co/models?search=minimax-m2.7+gguf](https://huggingface.co/models?search=minimax-m2.7+gguf) और uploader सत्यापित करें। Q4 से नीचे के MoE quants पर गुणवत्ता अलग-अलग होती है।
{% endhint %}

```bash
# जैसे ही कोई सामुदायिक Q4_K_M build उपलब्ध हो (पहले HuggingFace जाँचें)
docker exec ollama ollama pull minimax-m2.7:q4_K_M
docker exec ollama ollama run minimax-m2.7:q4_K_M

# या डाउनलोड किए गए GGUF पर सीधे llama.cpp के साथ
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/minimax-m2.7-q4_k_m.gguf \
  --n-gpu-layers 80 --ctx-size 32768 \
  --temp 1.0 --top-p 0.95 --top-k 40 \
  --port 8080 --host 0.0.0.0
```

केवल शौकिया उपयोग के लिए। वास्तविक workloads के लिए FP8 चेकपॉइंट के साथ vLLM या SGLang का उपयोग करें।

***

## विकल्प B — vLLM (Production API, अनुशंसित)

vLLM प्राथमिक serving target है। आधिकारिक FP8 चेकपॉइंट वही है जिसे आपको pull करना चाहिए — BF16 के समान गुणवत्ता, लगभग आधी VRAM पर।

### docker-compose.yml — 4× H100 80GB

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 4
      --max-model-len 65536
      --gpu-memory-utilization 0.88
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --served-model-name minimax-m2.7
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

### docker-compose.yml — 2× H200 141GB

कम करें `--tensor-parallel-size` को 2 पर और बढ़ाएँ `--max-model-len` हेडरूम का उपयोग करने के लिए:

```yaml
    command: >
      --model MiniMaxAI/MiniMax-M2.7
      --quantization fp8
      --tensor-parallel-size 2
      --max-model-len 131072
      --gpu-memory-utilization 0.90
      --enable-auto-tool-choice
      --tool-call-parser hermes
      --enable-chunked-prefill
      --served-model-name minimax-m2.7
      --trust-remote-code
```

### स्मोक टेस्ट

```bash
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-m2.7",
    "messages": [
      {"role": "system", "content": "आप एक वरिष्ठ इंजीनियर हैं। टूल कॉल्स के बीच तर्क करते समय Interleaved Thinking का उपयोग करें."},
      {"role": "user", "content": "टोकियो cancellation safety के लिए इस Rust async handler का ऑडिट करें: ..."}
    ],
    "max_tokens": 4096,
    "temperature": 1.0,
    "top_p": 0.95
  }'
```

{% hint style="info" %}
**कम न करें `temperature` 1.0 से नीचे।** MiniMax की अनुशंसित सैंपलिंग है `T=1.0, top_p=0.95, top_k=40`. Greedy decoding चुपचाप `<think>` मल्टी-टर्न टूल कॉल्स पर interleaving को तोड़ देता है।
{% endhint %}

***

## विकल्प C — SGLang

SGLang का MoE scheduler Hopper पर vLLM के मुकाबले प्रतिस्पर्धी है और अक्सर लंबे-कॉन्टेक्स्ट कोडिंग completions में जीतता है, क्योंकि EAGLE speculative decoding M2.7 के MTP modules के साथ स्टैक होता है।

```bash
docker pull lmsysorg/sglang:latest

python3 -m sglang.launch_server \\
  --model-path MiniMaxAI/MiniMax-M2.7 \
  --quantization fp8 \
  --tp-size 4 \
  --mem-fraction-static 0.88 \
  --context-length 65536 \
  --enable-mixed-chunk \
  --speculative-algorithm EAGLE \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4 \
  --served-model-name minimax-m2.7 \
  --trust-remote-code
```

लंबी agent traces पर vanilla vLLM की तुलना में लगभग 1.5–2× throughput लाभ की अपेक्षा करें। `--tp-size` को H200 पर 2 करें।

***

## Clore.ai GPU अनुशंसाएँ

| सेटअप                          | VRAM         | अपेक्षित प्रदर्शन                                 | Clore.ai लागत                                 |
| ------------------------------ | ------------ | ------------------------------------------------- | --------------------------------------------- |
| 1× RTX 4090 24GB + RAM offload | 24GB + 128GB | INT4 शौकिया, लगभग 5–10 tok/s                      | $0.14–0.42/hr                                 |
| 4× A100 80GB                   | 320GB        | BF16 sharded, लगभग 15–25 tok/s                    | [bare metal](https://clore.ai/bare-metal)     |
| **4× H100 80GB (FP8)**         | **320GB**    | **FP8 उत्पादन, लगभग 40–60 tok/s**                 | **\~$4.16/घंटा**                              |
| **2× H200 141GB (FP8)**        | **282GB**    | **FP8 उत्पादन, लगभग 50–70 tok/s, पूर्ण 200K ctx** | [**bare metal**](https://clore.ai/bare-metal) |
| 8× H100 80GB                   | 640GB        | BF16 पूर्ण, लगभग 80+ tok/s                        | \~$8.32/घंटा                                  |

{% hint style="success" %}
**सबसे अच्छा मूल्य:** FP8 चेकपॉइंट के साथ 2× H200। 4× H100 जैसी ही throughput श्रेणी, लेकिन tensor-parallel hops आधे, marketplace पर अक्सर प्रति दिन सस्ता, और पूर्ण 200K context के लिए पर्याप्त VRAM headroom मिलता है।
{% endhint %}

बॉक्स यहाँ किराए पर लें:

* [**bare metal के रूप में H200**](https://clore.ai/bare-metal) — 2× H200 FP8 deployment के लिए अनुशंसित
* [**H100 GPUs किराए पर लें**](https://clore.ai/rent-h100.html) — 4× H100 FP8 deployment के लिए
* [**bare metal के रूप में A100 80GB**](https://clore.ai/bare-metal) — BF16 multi-GPU fallback
* [**RTX 4090 किराए पर लें**](https://clore.ai/rent-4090.html) — केवल INT4 शौकिया उपयोग
* [**मार्केटप्लेस**](https://clore.ai/marketplace) — पूर्ण inventory, on-demand और spot bidding

***

## उपयोग के मामले

* **बहुभाषी SWE एजेंट** — Rust, Go, Java, Kotlin, Swift, और TypeScript को पहली-श्रेणी का व्यवहार मिलता है, केवल Python/JS को नहीं
* **दीर्घ-अवधि टूल-कॉलिंग लूप्स** — Interleaved Thinking सैकड़ों के पार reasoning trace को जीवित रखता है `tool_use` राउंड-ट्रिप्स
* **कोडबेस ऑडिट** — 200K context एक मध्यम-आकार की सेवा और उसके tests को एक ही prompt में फिट कर देता है
* **रिफैक्टर पाइपलाइन्स** — MTP modules के माध्यम से कई फ़ाइल संपादनों के दौरान स्थायी शुद्धता
* **एजेंट-ऑफ-एजेंट्स ऑर्केस्ट्रेशन** — M2.7 को planner के रूप में एक छोटे मॉडल (Qwen3.5, GLM-4.7-Flash) के साथ worker के रूप में जोड़ें
* **Claude Sonnet/Opus का स्वयं-होस्टेड विकल्प** गैर-व्यावसायिक कोडिंग शोध के लिए — लेकिन **पहले लाइसेंस पढ़ें**

***

## बेंचमार्क

{% hint style="warning" %}
**विक्रेता-प्रदत्त दावा — स्वतंत्र रूप से सत्यापित करें।** नीचे दिए गए अंक MiniMax की 9 अप्रैल 2026 की रिलीज़ नोट्स से लिए गए हैं। स्वतंत्र पुनरुत्पादन अभी भी आ रहे हैं।
{% endhint %}

| Benchmark        | MiniMax M2.7 | Claude Sonnet 4.5 (vendor ref) | Claude Opus 4.6 (vendor ref) | GPT-5.3-Codex |
| ---------------- | ------------ | ------------------------------ | ---------------------------- | ------------- |
| SWE-Pro          | **56.22%**   | \~55%                          | \~57.3%                      | 56.2%         |
| VIBE-Pro         | **55.6%**    | —                              | \~57%                        | —             |
| Terminal Bench 2 | **57.0%**    | —                              | —                            | —             |
| GDPval-AA (ELO)  | **1495**     | —                              | —                            | —             |

MiniMax की framing: M2.7, जिस agentic-coding suite की उन्हें परवाह है, उस पर Claude Sonnet 4.5 के बराबर या उससे बेहतर है, और SWE-Pro / VIBE-Pro पर Claude Opus 4.6 के कुछ अंकों के भीतर आता है। इसे एक दिशात्मक संकेत मानें, अंतिम रैंकिंग नहीं — बंद frontier models के साथ अंतर हर रिलीज़ पर कम होता जा रहा है।

***

## MiniMax M2 परिवार

| संस्करण  | जारी किया गया      | आर्किटेक्चरल फोकस                                 | के लिए अनुशंसित                                   |
| -------- | ------------------ | ------------------------------------------------- | ------------------------------------------------- |
| M2       | अक्टूबर 2025       | प्रारंभिक 229B MoE रिलीज़, RL-ट्यून की गई कोडिंग  | संदर्भ / ऐतिहासिक                                 |
| M2.1     | दिसंबर 2025        | **Interleaved Thinking** प्रस्तुत किया गया        | एजेंटों के लिए चलाने योग्य सबसे प्रारंभिक संस्करण |
| M2.5     | फ़रवरी 2026        | स्व-उत्क्रांतिकारी RL पोस्ट-ट्रेनिंग, लंबा संदर्भ | डिस्क-सीमित होने पर भी ठोस कोडिंग मॉडल            |
| **M2.7** | **9 अप्रैल, 2026** | **परिष्कृत बहुभाषी कोडिंग, MTP, FP8 आधिकारिक**    | **डिफ़ॉल्ट विकल्प — यही उपयोग करें**              |

यदि आप नए सिरे से शुरू कर रहे हैं, तो पहले के संस्करण छोड़कर सीधे M2.7 पर जाएँ। आर्किटेक्चरल अंतर बढ़ते जाते हैं और FP8 ergonomics स्पष्ट रूप से बेहतर हैं।

***

## समस्या निवारण

| समस्या                             | समाधान                                                                                                                              |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` FP8 लोड पर      | \~230GB VRAM चाहिए। 4× H100 80GB या 2× H200 141GB का उपयोग करें। `--max-model-len` को 32768 पर पहले रखें।                           |
| धीमा HuggingFace डाउनलोड           | `huggingface-cli download MiniMaxAI/MiniMax-M2.7 --local-dir ./weights --resume-download`. अपेक्षा करें \~230GB FP8 / \~460GB BF16। |
| टूल कॉल्स चुपचाप छोड़ दिए जाते हैं | सेट करें `--enable-auto-tool-choice --tool-call-parser hermes` vLLM में। M2.7 Hermes-शैली के tool tags का उपयोग करता है।            |
| `<think>` ब्लॉक्स खाली या विकृत    | सैंपलिंग होनी चाहिए `temperature=1.0, top_p=0.95, top_k=40`. Greedy decoding Interleaved Thinking को तोड़ देता है।                  |
| MTP त्रुटियाँ / आकार बेमेल         | vLLM को नवीनतम stable पर अपडेट करें; MTP समर्थन देर से आया और पुराने builds मॉड्यूल नहीं देते।                                      |
| H100 पर 200K context OOM करता है   | उपयोग करें `--enable-chunked-prefill` और शुरू करें `--max-model-len 65536`. पूर्ण 200K व्यावहारिक रूप से H200 की आवश्यकता रखता है।  |
| लाइसेंस भ्रम                       | डिफ़ॉल्ट = गैर-व्यावसायिक। ईमेल करें `api@minimax.io` किसी भी भुगतान किए गए उत्पाद उपयोग से पहले विषय "M2.7 licensing" के साथ।      |

***

## अगले चरण

* **ऑडियो सहोदर:** [MiniMax Speech](/guides/guides_v2-hi/audio-and-voice/minimax-speech.md) — वही विक्रेता, ऑडियो/वॉइस जनरेशन
* **ओपन-लाइसेंस विकल्प:** [GLM-5.1](/guides/guides_v2-hi/language-models/glm-5-1.md) — 744B / 40B active, MIT लाइसेंस, शीर्ष SWE-Bench Pro
* **विशाल-संदर्भ विकल्प:** [DeepSeek V4](/guides/guides_v2-hi/language-models/deepseek-v4.md) — 1M संदर्भ, मल्टीमॉडल
* **सस्ता agentic विकल्प:** [GLM-4.7 Flash](/guides/guides_v2-hi/language-models/glm-47-flash.md) — एकल H100 पर फिट होता है, MIT
* **Clore.ai marketplace:** [clore.ai/marketplace](https://clore.ai/marketplace) — spot market से H100/H200/A100

### लिंक्स

* [HuggingFace पर MiniMax M2.7](https://huggingface.co/MiniMaxAI/MiniMax-M2.7)
* [MiniMax M2.7 LICENSE](https://huggingface.co/MiniMaxAI/MiniMax-M2.7/blob/main/LICENSE) — व्यावसायिक उपयोग से पहले पढ़ें
* [MiniMax प्लेटफ़ॉर्म](https://www.minimax.io)
* [vLLM दस्तावेज़](https://docs.vllm.ai)
* [SGLang repo](https://github.com/sgl-project/sglang)
* [KTransformers](https://github.com/kvcache-ai/ktransformers)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/language-models/minimax-m27.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
