---
title: Claude dans Amazon Bedrock (Opus 4.7 et versions ultérieures)
url: https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock
description: Accédez aux modèles Claude via Amazon Bedrock avec l'authentification, la facturation et les limites de sécurité natives d'AWS.
---

Ce guide vous accompagne dans la configuration et la réalisation d'appels API à Claude dans Amazon Bedrock. Claude dans Amazon Bedrock s'exécute sur une infrastructure gérée par AWS avec un accès opérateur nul (le personnel d'Anthropic n'a aucun accès à l'infrastructure d'inférence), vous permettant de créer des applications sensibles entièrement à l'intérieur de la limite de sécurité d'AWS tout en utilisant la même structure de Messages API que vous utilisez avec l'API propriétaire d'Anthropic.

<Note>
  Cette page couvre Claude dans Amazon Bedrock, qui sert Claude via la Messages API à `/anthropic/v1/messages` sur une infrastructure gérée par AWS. L'intégration Amazon Bedrock précédente (les API `InvokeModel` et `Converse` avec des identifiants de modèle versionnés par ARN) reste disponible et est documentée dans [Claude sur Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy). Pour une alternative exploitée par Anthropic sur AWS avec facturation AWS Marketplace et un accès aux fonctionnalités généralement le jour même, consultez [Claude Platform sur AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws).
</Note>

## Accès

Amazon Bedrock définit les critères d'accès pour chaque modèle Claude individuellement. Claude Fable 5.1, Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5, Claude Opus 4.7 et Claude Haiku 4.5 sont ouverts à tous les clients Amazon Bedrock. Pour les critères actuels de tout autre modèle, consultez [l'accès aux modèles Amazon Bedrock](https://console.aws.amazon.com/bedrock/home#/modelaccess) dans la console AWS. Claude Mythos Preview nécessite une invitation via [Project Glasswing](https://anthropic.com/glasswing). Pour la disponibilité par région, consultez [Régions](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#regions).

## Prérequis

Avant de commencer, assurez-vous d'avoir :

* Un compte AWS avec [l'accès aux modèles Amazon Bedrock](https://console.aws.amazon.com/bedrock/home#/modelaccess) activé pour les modèles Claude que vous avez l'intention d'utiliser.
* L'[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installée et configurée (facultatif, pour la gestion des identifiants).

Claude Mythos Preview nécessite en outre un compte AWS dédié qui a été ajouté à la liste d'autorisation par l'équipe Bedrock Marketplace. Votre responsable de compte Anthropic peut soumettre votre ID de compte pour l'ajout à la liste d'autorisation (généralement traité dans les 24 heures), et AWS envoie un e-mail de bienvenue une fois l'opération terminée.

## Authentification

Claude dans Amazon Bedrock prend en charge trois voies d'authentification. Choisissez celle qui correspond le mieux à vos exigences de sécurité.

### Rôle de service Bedrock (recommandé)

Utilisez un rôle de service Bedrock avec des clés gérées par AWS pour l'accès le plus sécurisé et de longue durée :

<Steps>
  <Step title="Administrateur : provisionner le rôle de service">
    Un administrateur AWS provisionne un rôle de service Bedrock et accorde aux développeurs l'autorisation `iam:PassRole` sur l'ARN du rôle de service.
  </Step>

  <Step title="Développeur : transmettre le rôle">
    Lors de l'appel de l'API, Bedrock assume le rôle de service en votre nom. Consultez la [documentation Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html) pour savoir comment associer le rôle à vos requêtes.
  </Step>
</Steps>

### Rôles IAM assumés

Pour un accès fédéré par identité avec une session maximale de 12 heures :

<Steps>
  <Step title="Administrateur : configurer le rôle IAM">
    Créez un rôle IAM limité à vos modèles Claude. La politique de confiance nomme votre fournisseur d'identité (SAML, OIDC ou AWS Identity Center). La politique d'autorisations accorde `bedrock-mantle:CreateInference` uniquement sur les ARN de modèles autorisés.
  </Step>

  <Step title="Développeur : s'authentifier et assumer">
    Authentifiez-vous via votre fournisseur d'identité d'entreprise, puis assumez le rôle IAM. AWS STS émet des identifiants temporaires que le SDK ou la CLI utilise pour signer les requêtes.
  </Step>
</Steps>

### Jetons bearer

Pour un accès à court terme sans rôles IAM (12 heures maximum, le moins préféré) :

<Steps>
  <Step title="Administrateur : restreindre les types de jetons">
    Bloquez les clés de longue durée en attachant une politique qui refuse `bedrock:CallWithBearerToken` à moins que la condition `bedrock:BearerTokenType` ne corresponde à un jeton à court terme.
  </Step>

  <Step title="Développeur : générer un jeton">
    Utilisez la CLI `aws-bedrock-token-generator` pour générer un jeton bearer. Transmettez-le dans l'en-tête `x-api-key` à chaque requête.
  </Step>
</Steps>

## Installer un SDK

Les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d'Anthropic prennent en charge Claude dans Amazon Bedrock via un package ou un module spécifique à Bedrock.

<Tabs>
  <Tab title="Python">
    ```bash
    pip install -U "anthropic[bedrock]"
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/bedrock-sdk
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic.Bedrock
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go/bedrock
    ```
  </Tab>

  <Tab title="Java">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:2.73.0")
        implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java</artifactId>
            <version>2.73.0</version>
        </dependency>
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java-bedrock</artifactId>
            <version>2.73.0</version>
        </dependency>
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require anthropic-ai/sdk aws/aws-sdk-php
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "aws-sdk-core"
    ```
  </Tab>
</Tabs>

## Effectuer votre première requête

Le point de terminaison suit le modèle `https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages`. Contrairement à l'intégration basée sur `InvokeModel`, ce point de terminaison utilise le streaming SSE standard et la même structure de corps de requête que l'API propriétaire d'Anthropic.

Le SDK résout les identifiants et la région selon l'ordre de priorité AWS standard : les arguments du constructeur, puis les variables d'environnement (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_REGION`), puis le fichier de configuration AWS et la chaîne d'identifiants (SSO, rôles assumés, rôle de tâche ECS, IMDS).

<Tabs>
  <Tab title="cURL">
    ```bash
    curl https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
      --aws-sigv4 "aws:amz:us-east-1:bedrock-mantle" \
      --user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
      -H "x-amz-security-token: $AWS_SESSION_TOKEN" \
      -H "content-type: application/json" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "anthropic.claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [
          {"role": "user", "content": "Hello, Claude"}
        ]
      }'
    ```
  </Tab>

  <Tab title="CLI">
    La CLI `ant` ne prend pas en charge Amazon Bedrock. Utilisez cURL ou un SDK.
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrockMantle

    client = AnthropicBedrockMantle(aws_region="us-east-1")

    message = client.messages.create(
        model="anthropic.claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello, Claude"}],
    )

    print(next(block.text for block in message.content if block.type == "text"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import { AnthropicBedrockMantle } from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrockMantle({
      awsRegion: "us-east-1"
    });

    const message = await client.messages.create({
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    });

    const textBlock = message.content.find((block) => block.type === "text");
    if (textBlock) {
      console.log(textBlock.text);
    }
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    var client = new AnthropicBedrockMantleClient(new() { AwsRegion = "us-east-1" });

    var message = await client.Messages.Create(new()
    {
        Model = "anthropic.claude-opus-5-5",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
    });

    foreach (var item in message.Content)
    {
        if (item.Value is TextBlock block)
        {
            Console.WriteLine(block.Text);
            break;
        }
    }
    ```
  </Tab>

  <Tab title="Go">
    ```go
    client, err := bedrock.NewMantleClient(context.Background(), bedrock.MantleClientConfig{
    	AWSRegion: "us-east-1",
    })
    if err != nil {
    	panic(err)
    }

    message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    	Model:     "anthropic.claude-opus-5-5",
    	MaxTokens: 1024,
    	Messages: []anthropic.MessageParam{
    		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
    	},
    })
    if err != nil {
    	panic(err)
    }

    for _, block := range message.Content {
    	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
    		fmt.Println(textBlock.Text)
    		break
    	}
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockMantleBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.ContentBlock;
    import com.anthropic.models.messages.Message;
    import com.anthropic.models.messages.MessageCreateParams;

    void main() {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(BedrockMantleBackend.fromEnv())
            .build();

        Message message = client.messages().create(
            MessageCreateParams.builder()
                .model("anthropic.claude-opus-5-5")
                .maxTokens(1024)
                .addUserMessage("Hello, Claude")
                .build()
        );

        message.content().stream()
                .filter(ContentBlock::isText)
                .findFirst()
                .ifPresent(block -> IO.println(block.asText().text()));
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    use Anthropic\Bedrock\MantleClient;

    $client = new MantleClient(awsRegion: 'us-east-1');

    $message = $client->messages->create(
        model: 'anthropic.claude-opus-5-5',
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello, Claude'],
        ],
    );

    echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockMantleClient.new(aws_region: "us-east-1")

    message = client.messages.create(
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{role: "user", content: "Hello, Claude"}]
    )

    puts message.content.find { it.type == :text }.text
    ```
  </Tab>
</Tabs>

<Tip>
  Vous pouvez également créer le client standard avec `Anthropic` (go: `anthropic.NewClient()`; java: `AnthropicOkHttpClient.builder()`; csharp: `AnthropicClient`; php: `Anthropic\Client`; ruby: `Anthropic::Client`) : définissez `base_url` (typescript: `baseURL`; go: `option.WithBaseURL()`; java: `.baseUrl()`; csharp: `BaseUrl`; php: `baseUrl`) sur `https://bedrock-mantle.{region}.api.aws/anthropic` et transmettez votre jeton bearer en tant que `api_key` (typescript, php: `apiKey`; go: `option.WithAPIKey()`; java: `.apiKey()`; csharp: `ApiKey`). Cette méthode prend en charge uniquement l'authentification par jeton bearer. La signature SigV4 nécessite `AnthropicBedrockMantle` (csharp: `AnthropicBedrockMantleClient`; go: `bedrock.NewMantleClient`; java: `BedrockMantleBackend`; php: `MantleClient`; ruby: `Anthropic::BedrockMantleClient`).
</Tip>

## Modèles pris en charge

Les identifiants de modèle dans Claude dans Amazon Bedrock comportent le préfixe de fournisseur `anthropic.`. Les capacités et comportements des modèles sont documentés sur la page [Aperçu des modèles](https://platform.claude.com/docs/fr/models/overview).

| Model                                                                                       | Model ID                          | Access                                                                                              |
| :------------------------------------------------------------------------------------------ | :-------------------------------- | :-------------------------------------------------------------------------------------------------- |
| Claude Fable 5.1                                                                            | `anthropic.claude-fable-5-1`      | Open                                                                                                |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842)) | `anthropic.claude-mythos-5-1`     | Active (verification required)                                                                      |
| Claude Fable 5                                                                              | `anthropic.claude-fable-5`        | Open                                                                                                |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))   | `anthropic.claude-mythos-5`       | Active (verification required)                                                                      |
| Claude Mythos Preview ([limited availability](https://anthropic.com/glasswing))             | `anthropic.claude-mythos-preview` | Invitation only                                                                                     |
| Claude Opus 5.5                                                                             | `anthropic.claude-opus-5-5`       | [See Access](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 5                                                                               | `anthropic.claude-opus-5`         | [See Access](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 4.8                                                                             | `anthropic.claude-opus-4-8`       | Open                                                                                                |
| Claude Opus 4.7                                                                             | `anthropic.claude-opus-4-7`       | Open                                                                                                |
| Claude Sonnet 5.5                                                                           | `anthropic.claude-sonnet-5-5`     | [See Access](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Sonnet 5                                                                             | `anthropic.claude-sonnet-5`       | Open                                                                                                |
| Claude Haiku 5.5                                                                            | `anthropic.claude-haiku-5-5`      | [See Access](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Haiku 4.5                                                                            | `anthropic.claude-haiku-4-5`      | Open                                                                                                |

Utilisez la dernière version de Claude Code avec Claude dans Amazon Bedrock ; exécutez `claude update` pour effectuer la mise à niveau.

<Tip>
  Vous passez à un modèle Claude plus récent ? Dans Claude Code, exécutez `/claude-api migrate` pour appliquer les remplacements d'identifiants de modèle et les changements de paramètres non rétrocompatibles dans l'ensemble de votre base de code. La skill détecte la plateforme cloud ciblée par votre code et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour cette plateforme. Consultez [Migrer vers un modèle Claude plus récent](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
</Tip>

## Prise en charge des fonctionnalités

Pour la liste complète des fonctionnalités avec la disponibilité Amazon Bedrock, consultez [Aperçu des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview).

### Points forts des fonctionnalités prises en charge

* [Messages API](https://platform.claude.com/docs/fr/api/messages/create) (`/anthropic/v1/messages`)
* [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching)
* [Réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking)
* [Utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview), y compris l'[outil Bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool), l'[outil d'utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool), l'[outil de mémoire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool) et l'[outil d'édition de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool)
* [Citations](https://platform.claude.com/docs/fr/build-with-claude/citations)

### Fonctionnalités non prises en charge

* [Sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs)
* Sources d'entrée (sources URL pour les images et documents, Files API)
* Outils côté serveur (exécution de code, recherche web, récupération web, conseiller)
* Infrastructure d'agent (Agent Skills, connecteur MCP, appel d'outils programmatique)
* Points de terminaison API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Repli côté serveur (le [paramètre `fallbacks`](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback) ; utilisez plutôt le [modèle de repli côté client](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#client-side-fallback))
* Ensembles d'outils d'[utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool) et d'[utilisation du navigateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` et `browser_toolset_20260801` ne sont pas actuellement disponibles sur Amazon Bedrock ; les versions bêta de l'outil d'utilisation de l'ordinateur restent disponibles)

## Régions

Claude dans Amazon Bedrock est disponible dans les régions AWS suivantes. Amazon Bedrock propose deux types de points de terminaison :

* **Global :** routage dynamique entre toutes les régions disponibles pour une disponibilité maximale. Aucune majoration tarifaire.
* **Régional :** le point de terminaison est résolu vers la seule région AWS que vous spécifiez, pour répondre aux exigences de résidence des données. Les points de terminaison régionaux entraînent une majoration tarifaire de 10 % par rapport aux points de terminaison globaux. Pour effectuer un routage entre plusieurs régions au sein d'une zone géographique, utilisez un [profil d'inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) (US, EU, JP ou AU). Les régions marquées **Intra-région uniquement** dans le tableau prennent en charge le routage direct vers une seule région sans profil d'inférence.

Le point de terminaison global est disponible pour Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5 et Claude Haiku 4.5. Pour Claude Fable 5.1, les points de terminaison régionaux sont actuellement disponibles uniquement dans `us-east-1`. Claude Mythos Preview est uniquement régional et est disponible dans `us-east-1`.

| Région AWS       | Emplacement                    | Types de points de terminaison      |
| ---------------- | ------------------------------ | ----------------------------------- |
| `af-south-1`     | Afrique (Le Cap)               | Global                              |
| `ap-northeast-1` | Asie-Pacifique (Tokyo)         | Global, JP, Intra-région uniquement |
| `ap-northeast-2` | Asie-Pacifique (Séoul)         | Global                              |
| `ap-northeast-3` | Asie-Pacifique (Osaka)         | Global, JP                          |
| `ap-south-1`     | Asie-Pacifique (Mumbai)        | Global                              |
| `ap-south-2`     | Asie-Pacifique (Hyderabad)     | Global                              |
| `ap-southeast-1` | Asie-Pacifique (Singapour)     | Global                              |
| `ap-southeast-2` | Asie-Pacifique (Sydney)        | Global, AU                          |
| `ap-southeast-3` | Asie-Pacifique (Jakarta)       | Global                              |
| `ap-southeast-4` | Asie-Pacifique (Melbourne)     | Global, AU, Intra-région uniquement |
| `ca-central-1`   | Canada (Centre)                | Global, US                          |
| `ca-west-1`      | Canada Ouest (Calgary)         | Global                              |
| `eu-central-1`   | Europe (Francfort)             | Global, EU                          |
| `eu-central-2`   | Europe (Zurich)                | Global, EU                          |
| `eu-north-1`     | Europe (Stockholm)             | Global, EU, Intra-région uniquement |
| `eu-south-1`     | Europe (Milan)                 | Global, EU                          |
| `eu-south-2`     | Europe (Espagne)               | Global, EU                          |
| `eu-west-1`      | Europe (Irlande)               | Global, EU, Intra-région uniquement |
| `eu-west-2`      | Europe (Londres)               | Global, EU                          |
| `eu-west-3`      | Europe (Paris)                 | Global, EU                          |
| `il-central-1`   | Israël (Tel Aviv)              | Global                              |
| `me-central-1`   | Moyen-Orient (EAU)             | Global                              |
| `sa-east-1`      | Amérique du Sud (São Paulo)    | Global                              |
| `us-east-1`      | USA Est (Virginie du Nord)     | Global, US, Intra-région uniquement |
| `us-east-2`      | USA Est (Ohio)                 | Global, US, Intra-région uniquement |
| `us-west-1`      | USA Ouest (Californie du Nord) | Global, US                          |
| `us-west-2`      | USA Ouest (Oregon)             | Global, US, Intra-région uniquement |

## Quotas

Le quota par défaut est de 2 millions de tokens d'entrée par minute (TPM). Vous pouvez demander jusqu'à 5 millions de TPM d'entrée et 500 000 TPM de sortie sans approbation supplémentaire d'Anthropic. AWS applique des limites de requêtes par minute (RPM) du côté Bedrock ; contactez le support AWS pour les ajustements de RPM.

## Conservation des données

La gestion des données pour cette offre est régie par Amazon Bedrock. Pour plus de détails, consultez [Protection des données dans Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html).

## Surveillance et journalisation

Claude dans Amazon Bedrock émet des journaux vers CloudWatch et CloudTrail. Anthropic recommande de conserver les journaux d'activité sur une base glissante d'au moins 30 jours pour comprendre les modèles d'utilisation et enquêter sur les problèmes potentiels.

## Support

Pour obtenir de l'aide, contactez **[bedrock-ant-eap@amazon.com](mailto:bedrock-ant-eap@amazon.com)**. Incluez votre ID de compte AWS et le `request-id` de toute réponse API ayant échoué.

<Note>
  **Claude Mythos Preview** est un modèle en aperçu de recherche disponible pour les clients invités sur Amazon Bedrock. Pour plus d'informations, consultez [Project Glasswing](https://anthropic.com/glasswing).
</Note>
