┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP: มาตรฐาน USB-C สำหรับการผสานรวม AI                      │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ก่อน MCP (2023-2024):                          หลัง MCP (2025-2026):          │
│   ┌─────────────┐    ┌─────────────┐              ┌─────────────┐              │
│   │   Claude    │───▶│  Custom     │              │   MCP       │              │
│   │             │    │  Integration│              │   Client    │              │
│   └─────────────┘    └──────┬──────┘              └──────┬──────┘              │
│                             │                           │                      │
│   ┌─────────────┐    ┌──────┴──────┐              ┌──────┴──────┐              │
│   │   GPT-4     │───▶│  Custom     │              │  MCP Server │              │
│   │             │    │  Integration│              │  (Database) │              │
│   └─────────────┘    └──────┬──────┘              └─────────────┘              │
│                             │                                                   │
│   ┌─────────────┐    ┌──────┴──────┐              ┌─────────────┐              │
│   │   Gemini    │───▶│  Custom     │              │  MCP Server │              │
│   │             │    │  Integration│              │  (Slack)    │              │
│   └─────────────┘    └─────────────┘              └─────────────┘              │
│                                                                                 │
│   ผลลัพธ์: 10 การผสานรวม                     ผลลัพธ์: 1 โปรโตคอล ใช้กับเครื่องมือใดก็ได้│
│   สำหรับ 10 เครื่องมือ × 3 โมเดล              เขียนครั้งเดียว ใช้ได้ทุกที่       │
│   = 30 custom builds                          = ความเข้ากันได้สากล            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                     ช่องโหว่ความเป็นจริงด้านความปลอดภัยของ MCP                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  เมตริกการนำไปใช้:                      ความเป็นจริงด้านความปลอดภัย:           │
│  • 97M ดาวน์โหลด SDK ต่อเดือน           • 1,800+ เซิร์ฟเวอร์ไม่มีการตรวจสอบสิทธิ์│
│  • เซิร์ฟเวอร์สาธารณะ 10,000+           • OAuth ยังคงเป็น OPTIONAL ในข้อกำหนด  │
│  • Fortune 1000 กำลังปรับใช้             • บทช่วยสอนหลายส่วนสร้างก่อนการ      │
│  • การสนับสนุนอย่างเป็นทางการ: Anthropic, อัปเดตด้านความปลอดภัย              │
│    OpenAI, Google, Microsoft            • CVE-2025-49596: RCE ใน reference      │
│                                                                                 │
│  ปัญหา: การปรับใช้ "production" MCP ส่วนใหญ่ปฏิบัติตามบทช่วยสอนจาก              │
│  ตุลาคม 2024 — ก่อนที่การตรวจสอบสิทธิ์จะมีอยู่ พวกเขาสอดคล้องทางเทคนิค        │
│  แต่ไม่ปลอดภัยในการดำเนินงาน                                                │
│                                                                                 │
│  เหตุการณ์จริง:                                                               │
│  • พฤษภาคม 2025: ข้อบกพร่องการแยก tenant ส่งผลกระทบต่อธุรกิจ 1,000 แห่ง      │
│  • กันยายน 2025: เซิร์ฟเวอร์ MCP ที่เป็นอันตรายคัดลอกอีเมลไปยังผู้โจมตี         │
│  • Q1 2026: การปนเปื้อนข้อมูลข้ามองค์กรผ่านเซิร์ฟเวอร์ที่กำหนดค่าผิด            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                สถาปัตยกรรม AI การผลิต: MCP + n8n                               │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                        ชั้นการแสดงผล                                       │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │   Claude    │  │   ChatGPT   │  │   Cursor    │  │   Custom    │     │  │
│   │  │   Desktop   │  │   Desktop   │  │     IDE     │  │    Agent    │     │  │
│   │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘     │  │
│   └─────────┼────────────────┼────────────────┼────────────────┼────────────┘  │
│             │                │                │                │                 │
│             └────────────────┴────────────────┴────────────────┘                 │
│                                     │                                           │
│   ┌─────────────────────────────────┴─────────────────────────────────────────┐  │
│   │                      ชั้น MCP Gateway (ตัวเลือก)                          │  │
│   │              • การตรวจสอบสิทธิ์แบบรวมศูนย์                                │  │
│   │              • การบังคับใช้นโยบาย                                       │  │
│   │              • การจำกัดอัตรา                                          │  │
│   └─────────────────────────────────┬───────────────────────────────────────┘  │
│                                     │                                           │
│   ┌─────────────────────────────────▼─────────────────────────────────────────┐  │
│   │                     ชั้นการประสานงาน n8n                                 │  │
│   │  ┌───────────────────────────────────────────────────────────────────┐   │  │
│   │  │  Workflow Engine                                                 │   │  │
│   │  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌───────────┐│   │  │
│   │  │  │ MCP Nodes   │  │  Auth Mgmt  │  │   Error     │  │  Human-   ││   │  │
│   │  │  │ (Tools)     │  │ (OAuth/SSO) │  │  Handling   │  │ in-Loop  ││   │  │
│   │  │  └─────────────┘  └─────────────┘  └─────────────┘  └───────────┘│   │  │
│   │  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌───────────┐│   │  │
│   │  │  │  Audit      │  │  Queue      │  │   Batch     │  │  Notify   ││   │  │
│   │  │  │  Logging    │  │  Management │  │ Processing  │  │  & Alert  ││   │  │
│   │  │  └─────────────┘  └─────────────┘  └─────────────┘  └───────────┘│   │  │
│   │  └───────────────────────────────────────────────────────────────────┘   │  │
│   └─────────────────────────────────┬─────────────────────────────────────────┘  │
│                                     │                                           │
│   ┌─────────────────────────────────▼─────────────────────────────────────────┐  │
│   │                      ชั้น MCP Server                                     │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │  Database   │  │    Slack    │  │   GitHub    │  │   Stripe    │     │  │
│   │  │   (Supabase)│  │             │  │             │  │             │     │  │
│   │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘     │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐     │  │
│   │  │    CRM      │  │     ERP     │  │    Email    │  │  Internal   │     │  │
│   │  │(Salesforce) │  │             │  │             │  │    APIs     │     │  │
│   │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘     │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# PostgreSQL Database Server
npm install -g @modelcontextprotocol/server-postgres

# Slack Integration
npm install -g @modelcontextprotocol/server-slack

# GitHub Access
npm install -g @modelcontextprotocol/server-github

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token",
        "SLACK_TEAM_ID": "T0123456789"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
      }
    }
  }
}

// Workflow: Secure MCP Gateway
// วัตถุประสงค์: รวมศูนย์การตรวจสอบสิทธิ์และการบังคับใช้นโยบาย

// Node 1: Webhook Trigger (รับคำขอ MCP)
{
  "name": "คำขอ MCP",
  "type": "n8n-nodes-base.webhook",
  "webhookUri": "https://your-n8n.com/webhook/mcp-gateway",
  "responseMode": "responseNode",
  "path": "mcp-gateway"
}

// Node 2: การตรวจสอบการตรวจสอบสิทธิ์
{
  "name": "ตรวจสอบ API Key",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const apiKey = $headers['x-api-key'];
    const validKeys = await getValidApiKeys(); // ดึงจากตู้นิรภัยที่ปลอดภัย
    
    if (!validKeys.includes(apiKey)) {
      throw new Error('ไม่ได้รับอนุญาต: API Key ไม่ถูกต้อง');
    }
    
    // แยกบริบทผู้ใช้จาก API Key
    const userContext = await getUserFromApiKey(apiKey);
    
    return [{
      json: {
        ...$json,
        user_id: userContext.id,
        user_role: userContext.role,
        permissions: userContext.permissions
      }
    }];
  `
}

// Node 3: การบังคับใช้นโยบาย
{
  "name": "ตรวจสอบสิทธิ์",
  "type": "n8n-nodes-base.code",
  "jsCode": `
    const { user_role, permissions, mcp_server, operation } = $json;
    
    // กำหนดเมทริกซ์สิทธิ์
    const permissionMatrix = {
      'postgres': {
        'read': ['developer', 'analyst', 'admin'],
        'write': ['developer', 'admin'],
        'admin': ['admin']
      },
      'slack': {
        'post': ['developer', 'manager', 'admin'],
        'read': ['developer', 'analyst', 'manager', 'admin']
      },
      'github': {
        'read': ['developer', 'analyst', 'admin'],
        'write': ['developer', 'admin']
      }
    };
    
    const requiredPerm = permissionMatrix[mcp_server]?.[operation];
    if (!requiredPerm || !requiredPerm.includes(user_role)) {
      throw new Error(\`ห้าม: \${user_role} ไม่สามารถดำเนินการ \${operation} บน \${mcp_server}\`);
    }
    
    return [$json];
  `
}

// Node 4: การจำกัดอัตรา
{
  "name": "ตรวจสอบ Rate Limit",
  "type": "n8n-nodes-base.redis",
  "operation": "eval",
  "script": \`
    local key = KEYS[1]
    local limit = tonumber(ARGV[1])
    local window = tonumber(ARGV[2])
    
    local current = redis.call('GET', key)
    if current == false then
      redis.call('SET', key, 1, 'EX', window)
      return {1, limit}
    end
    
    current = tonumber(current)
    if current >= limit then
      return {0, limit - current}
    end
    
    redis.call('INCR', key)
    return {1, limit - current - 1}
  \`,
  "keys": ["rate_limit:{{ $json.user_id }}:{{ $json.mcp_server }}"],
  "args": ["100", "3600"] // 100 คำขอต่อชั่วโมง
}

// Node 5: เส้นทางไปยัง MCP Handler
{
  "name": "เส้นทางไปยัง Handler",
  "type": "n8n-nodes-base.switch",
  "rules": {
    "rules": [
      { "value": "={{ $json.mcp_server }}", "output": 0 },
      { "value": "={{ $json.mcp_server }}", "output": 1 },
      { "value": "={{ $json.mcp_server }}", "output": 2 }
    ]
  }
}

// Workflow: การดำเนินการฐานข้อมูลที่ปลอดภัยผ่าน MCP

// Node 1: PostgreSQL MCP Handler
{
  "name": "ดำเนินการคิวรี Postgres",
  "type": "n8n-nodes-base.postgres",
  "operation": "executeQuery",
  "connectionString": "={{ $credentials.postgres.connectionString }}",
  "query": "={{ $json.query }}",
  "parameters": "={{ $json.parameters }}"
}

// Node 2: บันทึก Audit แบบครอบคลุม
{
  "name": "บันทึกการเข้าถึงฐานข้อมูล",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "mcp_audit_log",
  "columns": {
    "timestamp": "={{ $now }}",
    "user_id": "={{ $json.user_id }}",
    "mcp_server": "postgres",
    "operation": "query",
    "query_hash": "={{ $crypto.md5($json.query) }}",
    "row_count": "={{ $json.row_count }}",
    "execution_time_ms": "={{ $json.execution_time }}",
    "client_ip": "={{ $headers['x-forwarded-for'] }}",
    "request_id": "={{ $execution.id }}"
  }
}

// Node 3: การตรวจจับ PII และการแจ้งเตือน
{
  "name": "ตรวจจับข้อมูลที่ละเอียดอ่อน",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const sensitivePatterns = [
      /\\b\\d{3}-\\d{2}-\\d{4}\\b/g, // SSN
      /\\b\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}\\b/g, // บัตรเครดิต
      /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b/g, // อีเมล
      /\\b(?:\\+?1[-.\\s]?)?\\(?[0-9]{3}\\)?[-.\\s]?[0-9]{3}[-.\\s]?[0-9]{4}\\b/g // โทรศัพท์
    ];
    
    const results = JSON.stringify($json.results);
    const detectedPatterns = [];
    
    sensitivePatterns.forEach((pattern, index) => {
      if (pattern.test(results)) {
        detectedPatterns.push(['SSN', 'Credit Card', 'Email', 'Phone'][index]);
      }
    });
    
    if (detectedPatterns.length > 0) {
      // กระตุ้นการแจ้งเตือนความปลอดภัย
      await sendSecurityAlert({
        user_id: $json.user_id,
        detected_types: detectedPatterns,
        request_id: $execution.id
      });
    }
    
    return [$json];
  \`
}

// Node 4: คืนค่าผลลัพธ์
{
  "name": "คืนค่าการตอบกลับ",
  "type": "n8n-nodes-base.respondToWebhook",
  "respondWith": "json",
  "responseBody": {
    "success": true,
    "data": "={{ $json.results }}",
    "metadata": {
      "row_count": "={{ $json.row_count }}",
      "execution_time_ms": "={{ $json.execution_time }}"
    }
  }
}

// Workflow: การอนุมัติจากมนุษย์สำหรับการดำเนินการ MCP ที่ละเอียดอ่อน

// Node 1: จำแนกระดับความเสี่ยง
{
  "name": "ประเมินความเสี่ยง",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const { mcp_server, operation, parameters } = $json;
    
    // เมทริกซ์การให้คะแนนความเสี่ยง
    let riskScore = 0;
    let riskFactors = [];
    
    // ความเสี่ยงของเซิร์ฟเวอร์
    const serverRisk = {
      'postgres': 2,
      'slack': 1,
      'github': 2,
      'stripe': 3
    };
    riskScore += serverRisk[mcp_server] || 1;
    
    // ความเสี่ยงของการดำเนินการ
    if (operation.includes('delete') || operation.includes('drop')) {
      riskScore += 3;
      riskFactors.push('การดำเนินการทำลาย');
    }
    if (operation.includes('write') || operation.includes('update')) {
      riskScore += 2;
      riskFactors.push('การดำเนินการเขียน');
    }
    
    // ความเสี่ยงปริมาณข้อมูล
    if (parameters?.row_limit > 10000) {
      riskScore += 1;
      riskFactors.push('ปริมาณสูง');
    }
    
    // กำหนดความต้องการการอนุมัติ
    const requiresApproval = riskScore >= 4;
    const approverLevel = riskScore >= 6 ? 'director' : 'manager';
    
    return [{
      json: {
        ...$json,
        risk_score: riskScore,
        risk_factors: riskFactors,
        requires_approval: requiresApproval,
        approver_level: approverLevel,
        auto_execute: !requiresApproval
      }
    }];
  \`
}

// Node 2: เส้นทางการตัดสินใจ
{
  "name": "เส้นทางตามความเสี่ยง",
  "type": "n8n-nodes-base.if",
  "conditions": {
    "boolean": [
      { "value1": "={{ $json.requires_approval }}", "value2": true }
    ]
  }
}

// สาขา 1: ดำเนินการโดยตรง (ความเสี่ยงต่ำ)
{
  "name": "ดำเนินการโดยตรง",
  "type": "n8n-nodes-base.executeWorkflow",
  "workflowId": "mcp-auto-execute",
  "data": "={{ $json }}"
}

// สาขา 2: ขอการอนุมัติ (ความเสี่ยงสูง)
{
  "name": "สร้างคำขออนุมัติ",
  "type": "n8n-nodes-base.postgres",
  "operation": "insert",
  "table": "mcp_approvals",
  "columns": {
    "request_id": "={{ $execution.id }}",
    "user_id": "={{ $json.user_id }}",
    "mcp_server": "={{ $json.mcp_server }}",
    "operation": "={{ $json.operation }}",
    "parameters": "={{ JSON.stringify($json.parameters) }}",
    "risk_score": "={{ $json.risk_score }}",
    "risk_factors": "={{ JSON.stringify($json.risk_factors) }}",
    "required_approver_level": "={{ $json.approver_level }}",
    "status": "pending",
    "created_at": "={{ $now }}"
  },
  "options": {
    "returnFields": ["id"]
  }
}

// Node 3: ส่งการแจ้งเตือนการอนุมัติ
{
  "name": "แจ้งเตือนผู้อนุมัติ",
  "type": "n8n-nodes-base.slack",
  "operation": "post",
  "channel": "#mcp-approvals",
  "blocks": [
    {
      "type": "header",
      "text": { "type": "plain_text", "text": "⚠️ การดำเนินการ MCP ที่มีความเสี่ยงสูงต้องการการอนุมัติ" }
    },
    {
      "type": "section",
      "fields": [
        { "type": "mrkdwn", "text": "*รหัสคำขอ:*\n{{ $json.request_id }}" },
        { "type": "mrkdwn", "text": "*ขอโดย:*\n{{ $json.user_id }}" },
        { "type": "mrkdwn", "text": "*เซิร์ฟเวอร์:*\n{{ $json.mcp_server }}" },
        { "type": "mrkdwn", "text": "*การดำเนินการ:*\n{{ $json.operation }}" },
        { "type": "mrkdwn", "text": "*คะแนนความเสี่ยง:*\n{{ $json.risk_score }}/10" },
        { "type": "mrkdwn", "text": "*ระดับที่ต้องการ:*\n{{ $json.approver_level }}" }
      ]
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*ปัจจัยความเสี่ยง:* {{ $json.risk_factors.join(', ') }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "✅ อนุมัติ" },
          "style": "primary",
          "action_id": "approve_mcp",
          "value": "{{ $json.request_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "❌ ปฏิเสธ" },
          "style": "danger",
          "action_id": "reject_mcp",
          "value": "{{ $json.request_id }}"
        },
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "👀 ดูรายละเอียด" },
          "url": "https://approvals.example.com/mcp/{{ $json.request_id }}"
        }
      ]
    }
  ]
}

// Node 4: รอการตอบกลับการอนุมัติ
{
  "name": "รอการตัดสินใจ",
  "type": "n8n-nodes-base.wait",
  "waitType": "webhook",
  "webhookSuffix": "mcp-approval-response",
  "continue": "receiveWebhook",
  "options": {
    "timeout": 86400 // 24 ชั่วโมง
  }
}

// Node 5: ประมวลผลการตัดสินใจการอนุมัติ
{
  "name": "ประมวลผลการตัดสินใจ",
  "type": "n8n-nodes-base.code",
  "jsCode": \`
    const decision = $json.decision;
    const approver = $json.approver;
    
    // อัปเดตบันทึกการอนุมัติ
    await updateApprovalStatus({
      request_id: $json.request_id,
      status: decision,
      approver: approver,
      decided_at: new Date().toISOString()
    });
    
    if (decision === 'approved') {
      // ดำเนินการ MCP
      return [{
        json: {
          ...$json,
          approved: true,
          approved_by: approver,
          execute: true
        }
      }];
    } else {
      // บันทึกการปฏิเสธและแจ้งเตือนผู้ขอ
      await notifyRejection($json.user_id, $json.request_id, $json.rejection_reason);
      return [{
        json: {
          ...$json,
          approved: false,
          rejection_reason: $json.rejection_reason
        }
      }];
    }
  \`
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│           Enterprise Support AI: การใช้งาน MCP + n8n                          │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  คำขอจากลูกค้า                                                                  │
│       │                                                                         │
│       ▼                                                                         │
│  ┌─────────────────────────────────┐                                           │
│  │   Claude Desktop (MCP Host)     │                                           │
│  │   • คำขอภาษาธรรมชาติ             │                                           │
│  │   • การจำแนกเจตนา                │                                           │
│  └──────────────┬──────────────────┘                                           │
│                 │                                                               │
│                 ▼                                                               │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    n8n Workflow: Support AI Orchestrator                 │   │
│  │                                                                          │   │
│  │  ┌─────────────┐     ┌─────────────┐     ┌─────────────┐               │   │
│  │  │  Auth Check │────▶│  Rate Limit │────▶│  Intent     │               │   │
│  │  │             │     │  Check      │     │  Router     │               │   │
│  │  └─────────────┘     └─────────────┘     └──────┬──────┘               │   │
│  │                                                  │                      │   │
│  │                    ┌─────────────┬───────────────┼─────────────┐        │   │
│  │                    ▼             ▼               ▼             ▼        │   │
│  │             ┌──────────┐ ┌──────────┐  ┌──────────┐ ┌──────────┐     │   │
│  │             │  Data    │ │  Ticket  │  │  Slack   │ │  Human   │     │   │
│  │             │  Query   │ │  Lookup  │  │  Notify  │ │  Escalate│     │   │
│  │             └────┬─────┘ └────┬─────┘  └────┬─────┘ └────┬─────┘     │   │
│  │                  │            │             │            │            │   │
│  │                  ▼            ▼             ▼            ▼            │   │
│  │  ┌─────────────────────────────────────────────────────────────────┐ │   │
│  │  │                    ชั้น Audit & Compliance                      │ │   │
│  │  │  • บันทึกคำขอทั้งหมด                                           │ │   │
│  │  │  • การตรวจจับและการปิดบัง PII                                  │ │   │
│  │  │  • workflows การอนุมัติสำหรับข้อมูลที่ละเอียดอ่อน                  │ │   │
│  │  │  • การบังคับใช้นโยบายการเก็บรักษา                                 │ │   │
│  │  └─────────────────────────────────────────────────────────────────┘ │   │
│  │                                                                     │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────────┐│
│  │                     ชั้น MCP Server                                      ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐   ││
│  │  │  PostgreSQL │  │  Zendesk    │  │   Slack     │  │  Internal   │   ││
│  │  │  (Customer  │  │  (Tickets)  │  │  (Updates)  │  │  CRM        │   ││
│  │  │   Data)     │  │             │  │             │  │             │   ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘   ││
│  └─────────────────────────────────────────────────────────────────────────┘│
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘