diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 458f902..8215f38 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -21,6 +21,8 @@ jobs: steps: - name: Checkout uses: actions/checkout@v5 + with: + fetch-depth: 0 - name: Install Rust toolchain run: | @@ -109,6 +111,31 @@ jobs: - name: Check Rust boundaries run: scripts/check-rust-boundaries.sh + - name: Run offline OpenAPI support corpus gate + run: cargo test -p crank-import --test corpus -- --test-threads=1 + + - name: Check OpenAPI matrix and corpus compatibility versions + env: + MATRIX_BASE_REF: ${{ gitea.base_ref }} + MATRIX_EVENT_BEFORE: ${{ gitea.event.before }} + run: | + if [ -n "$MATRIX_BASE_REF" ]; then + base_ref="origin/$MATRIX_BASE_REF" + elif [ -n "$MATRIX_EVENT_BEFORE" ] && ! printf '%s' "$MATRIX_EVENT_BEFORE" | grep -Eq '^0+$'; then + base_ref="$MATRIX_EVENT_BEFORE" + else + base_ref="$(git merge-base HEAD origin/main)" + fi + python3 scripts/check-openapi-matrix-compatibility.py --base "$base_ref" + + - name: Save OpenAPI corpus evidence + if: always() + uses: actions/upload-artifact@v4 + with: + name: openapi-corpus-evidence + path: crates/crank-import/target/openapi-corpus/evidence-*.json + if-no-files-found: warn + - name: Run clippy run: cargo clippy --workspace --all-targets --all-features --jobs "$CARGO_BUILD_JOBS" -- -D warnings diff --git a/Cargo.lock b/Cargo.lock index a51c073..92cb96b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -766,6 +766,7 @@ dependencies = [ "serde", "serde_json", "serde_yaml", + "sha2 0.10.9", "thiserror 2.0.18", "url", ] diff --git a/apps/admin-api/src/service/imports/import_plan.rs b/apps/admin-api/src/service/imports/import_plan.rs index 11dc890..cafb545 100644 --- a/apps/admin-api/src/service/imports/import_plan.rs +++ b/apps/admin-api/src/service/imports/import_plan.rs @@ -103,7 +103,9 @@ impl AdminService { let global_blocker = preview .findings .iter() - .find(|finding| finding.severity == ImportFindingSeverity::Error) + .find(|finding| { + finding.severity == ImportFindingSeverity::Error && finding.operation_key.is_none() + }) .map(|finding| finding.code.clone()); let mut planned = Vec::with_capacity(selected_keys.len()); diff --git a/apps/admin-api/tests/integration/openapi_import/import_plan_apply.rs b/apps/admin-api/tests/integration/openapi_import/import_plan_apply.rs index a6f7372..fdd1a2f 100644 --- a/apps/admin-api/tests/integration/openapi_import/import_plan_apply.rs +++ b/apps/admin-api/tests/integration/openapi_import/import_plan_apply.rs @@ -1,5 +1,34 @@ use serde_json::{Value, json}; use serial_test::serial; +use std::{sync::Arc, time::Duration}; + +use async_trait::async_trait; +use crank_community_mcp::session::InMemorySessionStore; +use crank_core::{ + MachineAccessMode, MachineCredentialVerifier, MachineCredentialVerifierError, + OperationSecurityLevel, PlatformApiKeyScope, VerifiedMachineCredential, +}; + +struct CorpusMcpCredentialVerifier; + +#[async_trait] +impl MachineCredentialVerifier for CorpusMcpCredentialVerifier { + async fn verify_bearer_token( + &self, + _workspace_slug: &str, + _agent_slug: &str, + token: &str, + ) -> Result, MachineCredentialVerifierError> { + Ok( + (token == "corpus-test-token").then_some(VerifiedMachineCredential { + machine_access_mode: MachineAccessMode::StaticAgentKey, + max_security_level: OperationSecurityLevel::Standard, + scopes: vec![PlatformApiKeyScope::Read, PlatformApiKeyScope::Write], + platform_api_key_id: None, + }), + ) + } +} use super::super::common::*; @@ -53,6 +82,7 @@ struct CreatedPlan { reference: String, digest: String, body: Value, + preview: Value, } async fn create_plan( @@ -111,6 +141,7 @@ async fn create_plan( reference, digest, body, + preview, } } @@ -287,6 +318,7 @@ async fn same_key_and_digest_replay_report_without_extra_draft_and_changed_diges reference: plan.reference.clone(), digest: "0".repeat(64), body: plan.body.clone(), + preview: plan.preview.clone(), }; let (changed_status, _) = apply_plan(&client, &base_url, &changed, "stable-apply-key").await; assert_eq!(changed_status, reqwest::StatusCode::CONFLICT); @@ -662,3 +694,153 @@ async fn disabled_auth_secret_rejects_apply_without_leaking_credentials() { assert_eq!(after["total"], 1); assert_eq!(after["items"][0]["name"], "beta"); } + +#[tokio::test(flavor = "multi_thread")] +#[serial] +async fn ac_4_corpus_operation_completes_the_real_http_to_mcp_workflow() { + use axum::{Json, Router}; + + let registry = test_registry().await; + let (request_tx, mut request_rx) = tokio::sync::mpsc::unbounded_channel(); + let upstream = + Router::new().fallback(move |method: axum::http::Method, uri: axum::http::Uri| { + let request_tx = request_tx.clone(); + async move { + request_tx.send((method, uri)).unwrap(); + Json(json!({"id":"corpus-0"})) + } + }); + let upstream_base = spawn_admin_api(upstream).await; + let storage = test_storage_root("corpus_ac4"); + let base_url = spawn_admin_api(build_test_app(registry.clone(), storage)).await; + let client = authorized_client(&base_url).await; + let fixture_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../crates/crank-import/tests/corpus/representative-00.json"); + let mut fixture: Value = serde_json::from_slice(&std::fs::read(fixture_path).unwrap()).unwrap(); + let upstream_origin = upstream_base + .as_ref() + .split("/api/admin/workspaces/") + .next() + .unwrap(); + fixture["servers"] = json!([{ "url": upstream_origin }]); + let document = serde_json::to_string(&fixture).unwrap(); + let plan = create_plan(&client, &base_url, &document, full_plan()).await; + assert_eq!(plan.body["counts"]["actionable"], 1); + let (status, report) = apply_plan(&client, &base_url, &plan, "corpus-ac4-import").await; + assert_eq!(status, reqwest::StatusCode::OK, "Apply failed: {report}"); + assert!(report_has_outcome_status(&report, "created")); + let operations = operation_list(&client, &base_url).await; + assert_eq!(operations["total"], 1); + assert_eq!(operations["items"][0]["status"], "draft"); + let operation_id = operations["items"][0]["id"].as_str().unwrap().to_owned(); + + // The admin test run performs the persisted Draft validation and a real + // HTTP execution against the local fixture server before publication. + let test_run = client + .post(format!("{base_url}/operations/{operation_id}/test-runs")) + .json(&json!({"version":1,"input":{}})) + .send() + .await + .unwrap(); + assert_eq!(test_run.status(), reqwest::StatusCode::OK); + let test_result: Value = test_run.json().await.unwrap(); + assert_eq!(test_result["ok"], true, "Draft test failed: {test_result}"); + let published = client + .post(format!("{base_url}/operations/{operation_id}/publish")) + .header( + reqwest::header::IF_MATCH, + operation_etag(&client, &base_url, &operation_id).await, + ) + .json(&json!({"version":1})) + .send() + .await + .unwrap(); + assert_eq!(published.status(), reqwest::StatusCode::OK); + + let agent = client.post(format!("{base_url}/agents")).json(&json!({ + "slug":"corpus-regression-agent","display_name":"Corpus Regression Agent", + "description":"Local corpus acceptance fixture","instructions":{},"tool_selection_policy":{} + })).send().await.unwrap().json::().await.unwrap(); + let agent_id = agent["agent_id"].as_str().unwrap(); + let bindings = client.post(format!("{base_url}/agents/{agent_id}/bindings")) + .header(reqwest::header::IF_MATCH, agent_etag(&client, &base_url, agent_id).await) + .json(&json!([{"operation_id":operation_id,"operation_version":1,"tool_name":"corpusOperation00","tool_title":"Synthetic operation 00","enabled":true}])) + .send().await.unwrap(); + assert_eq!(bindings.status(), reqwest::StatusCode::OK); + let agent_publish = client + .post(format!("{base_url}/agents/{agent_id}/publish")) + .header( + reqwest::header::IF_MATCH, + agent_etag(&client, &base_url, agent_id).await, + ) + .json(&json!({"version":1})) + .send() + .await + .unwrap(); + assert_eq!(agent_publish.status(), reqwest::StatusCode::OK); + + let mcp = crank_community_mcp::build_app( + registry, + Duration::ZERO, + None, + test_secret_crypto(), + crank_runtime::community_with_outbound_policy( + crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]), + ) + .build(), + crank_runtime::RequestRateLimiter::new( + crank_runtime::RequestRateLimitConfig::new(100, 100).unwrap(), + ), + Arc::new(crank_runtime::InMemoryCoordinationStateStore::default()), + Arc::new(InMemorySessionStore::default()), + Arc::new(CorpusMcpCredentialVerifier), + ); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let address = listener.local_addr().unwrap(); + tokio::spawn(async move { + axum::serve(listener, mcp).await.unwrap(); + }); + let mcp_base = format!("http://{address}"); + let mcp_url = format!("{mcp_base}/v1/default/corpus-regression-agent"); + let initialized = client.post(&mcp_url).bearer_auth("corpus-test-token") + .header("accept", "application/json, text/event-stream") + .json(&json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"corpus","version":"1"}}})) + .send().await.unwrap(); + assert_eq!(initialized.status(), reqwest::StatusCode::OK); + let session = initialized + .headers() + .get("mcp-session-id") + .unwrap() + .to_str() + .unwrap() + .to_owned(); + let notification = client + .post(&mcp_url) + .bearer_auth("corpus-test-token") + .header("accept", "application/json, text/event-stream") + .header("mcp-session-id", &session) + .header("mcp-protocol-version", "2025-11-25") + .json(&json!({"jsonrpc":"2.0","method":"notifications/initialized","params":{}})) + .send() + .await + .unwrap(); + assert_eq!(notification.status(), reqwest::StatusCode::ACCEPTED); + let called = client.post(&mcp_url).bearer_auth("corpus-test-token") + .header("accept", "application/json, text/event-stream").header("mcp-session-id", session) + .header("mcp-protocol-version", "2025-11-25") + .json(&json!({"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"corpusOperation00","arguments":{}}})) + .send().await.unwrap(); + assert_eq!(called.status(), reqwest::StatusCode::OK); + let call: Value = called.json().await.unwrap(); + assert_eq!(call["result"]["isError"], false, "MCP call failed: {call}"); + assert_eq!(call["result"]["structuredContent"]["id"], "corpus-0"); + for stage in ["Draft test run", "MCP call"] { + let (method, uri) = request_rx + .try_recv() + .unwrap_or_else(|_| panic!("{stage} missed upstream")); + assert_eq!(method, axum::http::Method::GET, "{stage}"); + assert_eq!(uri.path(), "/items/0", "{stage}"); + } +} + +mod corpus_hostile; diff --git a/apps/admin-api/tests/integration/openapi_import/import_plan_apply/corpus_hostile.rs b/apps/admin-api/tests/integration/openapi_import/import_plan_apply/corpus_hostile.rs new file mode 100644 index 0000000..3eb82e3 --- /dev/null +++ b/apps/admin-api/tests/integration/openapi_import/import_plan_apply/corpus_hostile.rs @@ -0,0 +1,295 @@ +use super::*; + +#[tokio::test(flavor = "multi_thread")] +#[serial] +async fn ac_5_hostile_corpus_cases_are_bounded_atomic_and_redacted() { + let registry = test_registry().await; + let base_url = spawn_admin_api(build_test_app(registry, test_storage_root("corpus_ac5"))).await; + let client = authorized_client(&base_url).await; + let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) + .join("../../crates/crank-import/tests/corpus"); + let hostile_xml = std::fs::read_to_string(root.join("hostile-xml.json")).unwrap(); + let before = operation_list(&client, &base_url).await; + let started = std::time::Instant::now(); + let plan = create_plan(&client, &base_url, &hostile_xml, full_plan()).await; + assert!( + started.elapsed() < Duration::from_secs(5), + "hostile document exceeded bounded test budget" + ); + assert!( + plan.body["counts"]["blocked"].as_u64().unwrap_or(0) > 0, + "hostile XML must be a blocker: {}", + plan.body + ); + let xml_candidate = &plan.preview["preview"]["groups"][0]["operations"][0]; + assert_eq!(xml_candidate["key"], "GET /xml"); + assert!( + xml_candidate["findings"] + .as_array() + .is_some_and(|findings| findings.iter().any(|finding| finding["code"] + == "unsupported_xml_response_media_type" + && finding["severity"] == "error")), + "HTTP preview must expose the exact XML blocker: {}", + plan.preview + ); + assert_eq!( + plan.body["candidates"][0]["reason"], "unsupported_xml_response_media_type", + "HTTP plan must retain the XML blocker: {}", + plan.body + ); + let (status, report) = apply_plan(&client, &base_url, &plan, "corpus-ac5-hostile").await; + assert_eq!( + status, + reqwest::StatusCode::CONFLICT, + "blocker must reject atomically: {report}" + ); + assert_eq!(operation_list(&client, &base_url).await, before); + + let secret = std::fs::read_to_string(root.join("hostile-secret.json")).unwrap(); + let secret_plan = create_plan(&client, &base_url, &secret, full_plan()).await; + let exposed = format!("{}{}", secret_plan.preview, secret_plan.body); + assert!( + !exposed.contains("sk_test_corpus_secret_canary"), + "secret canary leaked into plan evidence" + ); + assert_eq!(operation_list(&client, &base_url).await, before); + + for file in ["hostile-malformed.json", "hostile-oversized.json"] { + let source = std::fs::read(root.join(file)).unwrap(); + let started = std::time::Instant::now(); + let upload = reqwest::multipart::Part::bytes(source) + .file_name(file) + .mime_str("application/json") + .unwrap(); + let response = client + .post(format!("{base_url}/imports/openapi/preview")) + .multipart(reqwest::multipart::Form::new().part("file", upload)) + .send() + .await + .unwrap(); + let status = response.status(); + let body = response.text().await.unwrap_or_default(); + assert!( + !status.is_success(), + "{file} unexpectedly passed preview: {body}" + ); + assert!( + started.elapsed() < Duration::from_secs(5), + "{file} exceeded bounded upload/parse time" + ); + assert!( + !body.contains("sk_test_corpus_secret_canary"), + "hostile error response leaked a secret canary" + ); + assert_eq!( + operation_list(&client, &base_url).await, + before, + "{file} mutated the operation registry" + ); + } + + // Real HTTP preview+plan: a root security requirement combined with an + // explicit empty operation override must leave the public operation + // actionable and block only the inherited one. No Apply mutation follows. + let mixed_security: Value = serde_json::json!({ + "openapi": "3.0.3", + "info": { "title": "Mixed security plan probe", "version": "1" }, + "servers": [{ "url": "https://security.example.test" }], + "components": { "securitySchemes": { "probe": { "type": "http", "scheme": "basic" } } }, + "security": [{ "probe": [] }], + "paths": { + "/public": { "get": { "security": [], "operationId": "securityPublic", + "responses": { "200": { "description": "ok" } } } }, + "/secured": { "get": { "operationId": "securitySecured", + "responses": { "200": { "description": "ok" } } } } + } + }); + let security_mixed = serde_json::to_string(&mixed_security).unwrap(); + let security_plan = create_plan(&client, &base_url, &security_mixed, full_plan()).await; + assert_eq!( + security_plan.body["counts"]["selected"], 2, + "{}", + security_plan.body + ); + assert_eq!( + security_plan.body["counts"]["actionable"], 1, + "{}", + security_plan.body + ); + assert_eq!( + security_plan.body["counts"]["blocked"], 1, + "{}", + security_plan.body + ); + let security_candidates = security_plan.body["candidates"].as_array().unwrap(); + let by_key = |key: &str| { + security_candidates + .iter() + .find(|candidate| candidate["key"] == key) + .unwrap_or_else(|| panic!("candidate {key} missing: {}", security_plan.body)) + }; + let public = by_key("GET /public"); + let secured = by_key("GET /secured"); + assert_eq!( + public["state"].as_str(), + Some("actionable"), + "public candidate with empty security override must stay actionable: {}", + security_plan.body + ); + assert!( + public["reason"].is_null(), + "public candidate must not carry a security blocker: {}", + security_plan.body + ); + assert_eq!( + secured["state"].as_str(), + Some("blocked"), + "inherited security requirement must block the affected candidate: {}", + security_plan.body + ); + assert_eq!( + secured["reason"].as_str(), + Some("unsupported_security_requirement"), + "secured candidate must expose the exact security blocker: {}", + security_plan.body + ); + assert_eq!( + operation_list(&client, &base_url).await, + before, + "security-scoped plan must not mutate the operation registry" + ); + let (blocked_status, blocked_report) = apply_plan( + &client, + &base_url, + &security_plan, + "corpus-ac5-security-blocked", + ) + .await; + assert_eq!( + blocked_status, + reqwest::StatusCode::CONFLICT, + "{blocked_report}" + ); + assert_eq!(operation_list(&client, &base_url).await, before); + + let public_plan = create_plan( + &client, + &base_url, + &security_mixed, + json!({ + "selection_mode": "partial", + "selected_operation_keys": ["GET /public"] + }), + ) + .await; + assert_eq!(public_plan.body["counts"]["actionable"], 1); + assert_eq!(public_plan.body["counts"]["blocked"], 0); + let (public_status, public_report) = apply_plan( + &client, + &base_url, + &public_plan, + "corpus-ac5-security-public", + ) + .await; + assert_eq!(public_status, reqwest::StatusCode::OK, "{public_report}"); + assert!(report_has_outcome_status(&public_report, "created")); + let after = operation_list(&client, &base_url).await; + assert_eq!(after["total"], 1, "{after}"); +} + +#[tokio::test(flavor = "multi_thread")] +#[serial] +async fn p0_api_malformed_local_security_is_atomic_across_openapi_versions() { + for (version, document) in [ + ( + "openapi-3.1", + serde_json::json!({ + "openapi": "3.1.0", + "info": { "title": "Security API regression", "version": "1" }, + "servers": [{ "url": "https://security.example.test" }], + "security": [{ "probe": [] }], + "paths": { + "/bad": { "get": { "security": "basic", "operationId": "badOp", + "responses": { "200": { "description": "ok" } } } }, + "/public": { "get": { "security": [], "operationId": "publicOp", + "responses": { "200": { "description": "ok" } } } } + } + }), + ), + ( + "swagger-2.0", + serde_json::json!({ + "swagger": "2.0", + "info": { "title": "Security API regression", "version": "1" }, + "host": "security.example.test", + "schemes": ["https"], + "security": [{ "apiKey": [] }], + "paths": { + "/bad": { "get": { "security": "apikey", "operationId": "badOp", + "responses": { "200": { "description": "ok" } } } }, + "/public": { "get": { "security": [], "operationId": "publicOp", + "responses": { "200": { "description": "ok" } } } } + } + }), + ), + ] { + let registry = test_registry().await; + let base_url = spawn_admin_api(build_test_app( + registry, + test_storage_root(&format!("security_api_{version}")), + )) + .await; + let client = authorized_client(&base_url).await; + let source = serde_json::to_string(&document).unwrap(); + let before = operation_list(&client, &base_url).await; + + let plan = create_plan(&client, &base_url, &source, full_plan()).await; + assert_eq!( + plan.body["counts"]["actionable"], 1, + "{version}: {}", + plan.body + ); + assert_eq!( + plan.body["counts"]["blocked"], 1, + "{version}: {}", + plan.body + ); + let candidates = plan.body["candidates"].as_array().unwrap(); + let bad = candidates + .iter() + .find(|item| item["key"] == "GET /bad") + .unwrap(); + let public = candidates + .iter() + .find(|item| item["key"] == "GET /public") + .unwrap(); + assert_eq!(bad["state"], "blocked", "{version}: {}", plan.body); + assert_eq!(bad["reason"], "unsupported_security_requirement"); + assert_eq!(public["state"], "actionable", "{version}: {}", plan.body); + assert!(public["reason"].is_null()); + + let (status, report) = apply_plan(&client, &base_url, &plan, "security-full").await; + assert_eq!(status, reqwest::StatusCode::CONFLICT, "{version}: {report}"); + assert_eq!(operation_list(&client, &base_url).await, before); + + let public_plan = create_plan( + &client, + &base_url, + &source, + json!({ + "selection_mode": "partial", + "selected_operation_keys": ["GET /public"] + }), + ) + .await; + assert_eq!(public_plan.body["counts"]["actionable"], 1); + assert_eq!(public_plan.body["counts"]["blocked"], 0); + let (status, report) = + apply_plan(&client, &base_url, &public_plan, "security-public").await; + assert_eq!(status, reqwest::StatusCode::OK, "{version}: {report}"); + assert!(report_has_outcome_status(&report, "created")); + let after = operation_list(&client, &base_url).await; + assert_eq!(after["total"], 1, "{version}: {after}"); + assert_eq!(after["items"][0]["status"], "draft"); + } +} diff --git a/crates/crank-import/Cargo.toml b/crates/crank-import/Cargo.toml index 1c13ebe..185340b 100644 --- a/crates/crank-import/Cargo.toml +++ b/crates/crank-import/Cargo.toml @@ -13,5 +13,6 @@ crank-schema = { path = "../crank-schema" } serde.workspace = true serde_json.workspace = true serde_yaml.workspace = true +sha2.workspace = true thiserror.workspace = true url.workspace = true diff --git a/crates/crank-import/src/rest/mod.rs b/crates/crank-import/src/rest/mod.rs index 532536a..d04742c 100644 --- a/crates/crank-import/src/rest/mod.rs +++ b/crates/crank-import/src/rest/mod.rs @@ -12,6 +12,7 @@ mod normalize_finding_validation; mod normalize_limits; mod normalize_projection; mod normalize_schema; +mod normalize_security; mod openapi3; mod openapi3_findings; mod payload; diff --git a/crates/crank-import/src/rest/normalize.rs b/crates/crank-import/src/rest/normalize.rs index 72a6f29..65c681f 100644 --- a/crates/crank-import/src/rest/normalize.rs +++ b/crates/crank-import/src/rest/normalize.rs @@ -146,6 +146,7 @@ pub fn normalize_verified_bundle( } None => return Err(ImportParseError::UnsupportedDocument), }; + super::normalize_security::append_security_requirement_findings(&mut parsed, &root); super::metadata_findings::collect_secret_like_examples( &root, "", @@ -238,6 +239,8 @@ fn preview_from_operations<'a>( .push(candidate); } + super::normalize_security::attach_operation_findings(&mut groups, &findings); + sort_findings(&mut findings); ImportPreview { source: source.clone(), diff --git a/crates/crank-import/src/rest/normalize_finding_validation.rs b/crates/crank-import/src/rest/normalize_finding_validation.rs index 002ec27..39174ae 100644 --- a/crates/crank-import/src/rest/normalize_finding_validation.rs +++ b/crates/crank-import/src/rest/normalize_finding_validation.rs @@ -57,6 +57,10 @@ pub(super) fn matches_source( pointer.contains("/example") && matches!(&node.value, CanonicalSourceValue::String(value) if secret_like(pointer, value)) } "invalid_server" if is_error => invalid_server(pointer, node), + "unsupported_security_requirement" if is_error => { + matches!(&node.value, CanonicalSourceValue::Object(fields) if !fields.is_empty()) + || invalid_security_requirement(pointer, node) + } _ => false, } } @@ -201,6 +205,31 @@ fn secret_like(pointer: &str, value: &str) -> bool { || value.starts_with("sk-") } +/// Accepts malformed `security` shapes at their scoped source location only: +/// the document `security` member, an operation `security` member, or a +/// non-object item of the corresponding security array. An object is valid +/// only as an array item, including the empty `{}` public alternative. +fn invalid_security_requirement(pointer: &str, node: &CanonicalSourceNode) -> bool { + const METHODS: &[&str] = &[ + "get", "post", "put", "patch", "delete", "head", "options", "trace", "connect", + ]; + let is_index = |part: &str| !part.is_empty() && part.bytes().all(|b| b.is_ascii_digit()); + let segments: Vec<&str> = pointer.split('/').collect(); + match segments.as_slice() { + ["", "security"] => true, + ["", "security", index] => { + is_index(index) && !matches!(&node.value, CanonicalSourceValue::Object(_)) + } + ["", "paths", _, method, "security"] => METHODS.contains(method), + ["", "paths", _, method, "security", index] => { + METHODS.contains(method) + && is_index(index) + && !matches!(&node.value, CanonicalSourceValue::Object(_)) + } + _ => false, + } +} + fn invalid_server(pointer: &str, node: &CanonicalSourceNode) -> bool { if pointer == "/host" { return !matches!(&node.value, CanonicalSourceValue::String(host) if !host.is_empty() && !host.contains('@') && !host.chars().any(char::is_whitespace)); diff --git a/crates/crank-import/src/rest/normalize_security.rs b/crates/crank-import/src/rest/normalize_security.rs new file mode 100644 index 0000000..2e47e27 --- /dev/null +++ b/crates/crank-import/src/rest/normalize_security.rs @@ -0,0 +1,166 @@ +//! Effective per-operation security scopes for the OpenAPI importer. +use serde_json::Value; + +use super::{ + model::{ + ImportFinding, ImportFindingSeverity, ImportGroupPreview, RestImportDocument, + RestImportOperation, SourceLocation, + }, + normalize_coverage, +}; + +pub(super) fn attach_operation_findings( + groups: &mut std::collections::BTreeMap, + findings: &[ImportFinding], +) { + for group in groups.values_mut() { + for candidate in &mut group.operations { + let additions = findings + .iter() + .filter(|finding| { + finding.severity == ImportFindingSeverity::Error + && finding.operation_key.as_deref() == Some(candidate.key.as_str()) + && !candidate.findings.iter().any(|existing| { + existing.code == finding.code + && existing.severity == finding.severity + && existing.message == finding.message + }) + }) + .cloned() + .collect::>(); + candidate.findings.extend(additions); + } + } +} + +/// Computes the effective security requirements for every candidate operation +/// and attaches source-located blockers to precisely the affected candidates. +/// +/// Effective requirements follow the OpenAPI semantics: an operation that +/// declares its own `security` member wins over the document root; an empty +/// array (`security: []`) explicitly disables inheritance. Within a +/// requirement array the items are alternatives (OR): an empty requirement +/// object `{}` is the public alternative and makes the whole operation +/// public, so no blocker is produced for that operation. +/// +/// A malformed security shape — a non-array `security` value or a non-object +/// array item — must never be discarded silently: the affected operation +/// receives one blocker with the exact source location. A supported non-empty +/// requirement remains a blocker until an administrator binds a compatible +/// Auth Profile. +pub(super) fn append_security_requirement_findings(parsed: &mut RestImportDocument, root: &Value) { + let operations = &parsed.operations; + let findings = &mut parsed.findings; + let locations = &mut parsed.internal_finding_locations; + let root_security = root.get("security"); + for operation in operations { + let Some(path_item) = root + .pointer(&format!( + "/paths/{}", + normalize_coverage::escape_pointer(&operation.path) + )) + .and_then(|item| item.get(method_as_lower(operation))) + else { + continue; + }; + let Some(security) = path_item + .get("security") + .or_else(|| root_security.filter(|_| path_item.get("security").is_none())) + else { + continue; + }; + let base_pointer = if path_item.get("security").is_some() { + format!( + "/paths/{}/{}/security", + normalize_coverage::escape_pointer(&operation.path), + method_as_lower(operation) + ) + } else { + "/security".to_owned() + }; + let alternatives = match security.as_array() { + Some(alternatives) => alternatives, + None => { + push_security_blocker( + findings, + locations, + operation, + &base_pointer, + "security имеет некорректный формат: ожидается массив требований; операции с незапакованным блоком безопасности не публикуются.", + ); + continue; + } + }; + // Validate the item shapes first: only a fully well-formed array may + // use the empty requirement object `{}` as its public OR alternative. + if !alternatives + .iter() + .all(|requirement| requirement.as_object().is_some()) + { + for (index, requirement) in alternatives.iter().enumerate() { + let pointer = format!("{base_pointer}/{index}"); + match requirement.as_object() { + Some(schemes) if schemes.is_empty() => { + // In a malformed array the empty alternative does + // not make the operation public, but it also cannot + // block on its own. + continue; + } + Some(_) => push_security_blocker( + findings, + locations, + operation, + &pointer, + "Требование безопасности должно быть привязано к настроенному Auth Profile перед публикацией этой операции; остальные операции не блокируются.", + ), + None => push_security_blocker( + findings, + locations, + operation, + &pointer, + "security содержит альтернативу без объекта требований: формат не поддерживается, операция не публикуется.", + ), + } + } + continue; + } + if alternatives.iter().any(|requirement| { + requirement + .as_object() + .is_some_and(serde_json::Map::is_empty) + }) { + continue; + } + for (index, _) in alternatives.iter().enumerate() { + push_security_blocker( + findings, + locations, + operation, + &format!("{base_pointer}/{index}"), + "Требование безопасности должно быть привязано к настроенному Auth Profile перед публикацией этой операции; остальные операции не блокируются.", + ); + } + } +} + +fn push_security_blocker( + findings: &mut Vec, + locations: &mut Vec>, + operation: &RestImportOperation, + pointer: &str, + message: &str, +) { + findings.push(ImportFinding { + code: "unsupported_security_requirement".to_owned(), + severity: ImportFindingSeverity::Error, + message: message.to_owned(), + operation_key: Some(operation.key.clone()), + }); + locations.push(Some(SourceLocation { + pointer: pointer.to_owned(), + })); +} + +fn method_as_lower(operation: &RestImportOperation) -> String { + format!("{:?}", operation.method).to_ascii_lowercase() +} diff --git a/crates/crank-import/target/openapi-corpus/evidence-be17fbf86429a8953acba4f3e8114d47c088305c0b1720678c4ffea8476f4f24.json b/crates/crank-import/target/openapi-corpus/evidence-be17fbf86429a8953acba4f3e8114d47c088305c0b1720678c4ffea8476f4f24.json new file mode 100644 index 0000000..18426d4 --- /dev/null +++ b/crates/crank-import/target/openapi-corpus/evidence-be17fbf86429a8953acba4f3e8114d47c088305c0b1720678c4ffea8476f4f24.json @@ -0,0 +1,29 @@ +{ + "actionable_count": 50, + "content_digest": "296bb06a311615952c4688089515f514d417bf75b05645fb82ffaa41b92c73ad", + "content_digest_algorithm": "sha256", + "content_digest_definition": "SHA-256 of compact key-sorted JSON before the content_digest field is added.", + "corpus_version": "1.0.3", + "denominator": 50, + "evidence_identity": "be17fbf86429a8953acba4f3e8114d47c088305c0b1720678c4ffea8476f4f24", + "evidence_version": "1.0.0", + "exclusions": [], + "manifest_digest": "2abf220447fc73547583eab65370b84d1f3353a203909e16216d48b055919b47", + "matrix_contract": { + "construct_rows": 384, + "semantic_probes": "AC-1 runs a generated normalizer probe for every matrix row, including every 2xx status in all three formats." + }, + "matrix_digest": "29f1e93850b057bb374895d60a8b2dacc8d01371b53d579f558c9dd2b85aa209", + "matrix_version": "1.0.2", + "method": "real normalize_verified_document + preview_from_ir; every NormalizedIr passed validate_normalized_ir", + "raw_counts": { + "covered_source_constructs": 1837, + "documents": 63, + "findings": 0, + "representative_operations": 50, + "semantic_coverage_entries": 514, + "source_constructs": 1837 + }, + "silent_loss_count": 0, + "uncovered_source_constructs": [] +} \ No newline at end of file diff --git a/crates/crank-import/tests/corpus.rs b/crates/crank-import/tests/corpus.rs new file mode 100644 index 0000000..d14c01c --- /dev/null +++ b/crates/crank-import/tests/corpus.rs @@ -0,0 +1,973 @@ +//! Offline regression gates for the versioned OpenAPI support matrix and corpus. +use crank_import::rest::model::CoverageDisposition; +use crank_import::rest::model::{CanonicalSourceNode, CanonicalSourceValue}; +use crank_import::rest::{ + ImportParseError, NormalizationConfig, SourceDigest, normalize_verified_document, + preview_from_ir, validate_normalized_ir, +}; +use serde::Deserialize; +use serde_json::{Value, json}; +use sha2::{Digest, Sha256}; +use std::{ + fs, + path::{Path, PathBuf}, +}; + +#[path = "corpus/matrix.rs"] +mod matrix; + +fn tests_root() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")).join("tests") +} +fn hex(bytes: impl AsRef<[u8]>) -> String { + Sha256::digest(bytes) + .iter() + .map(|b| format!("{b:02x}")) + .collect() +} +fn canonical_json(value: &Value) -> Vec { + serde_json::to_vec(value).expect("JSON values serialize") +} +fn escape_pointer(value: &str) -> String { + value.replace('~', "~0").replace('/', "~1") +} +fn source_ledger( + value: &Value, + pointer: &str, + ledger: &mut std::collections::BTreeMap, +) { + assert!(ledger.insert(pointer.to_owned(), value.clone()).is_none()); + match value { + Value::Array(items) => { + for (index, item) in items.iter().enumerate() { + source_ledger(item, &format!("{pointer}/{index}"), ledger); + } + } + Value::Object(fields) => { + for (key, item) in fields { + source_ledger(item, &format!("{pointer}/{}", escape_pointer(key)), ledger); + } + } + _ => {} + } +} +fn canonical_source_ledger( + node: &CanonicalSourceNode, + ledger: &mut std::collections::BTreeMap, +) -> Value { + let value = match &node.value { + CanonicalSourceValue::Null => Value::Null, + CanonicalSourceValue::Boolean(value) => json!(value), + CanonicalSourceValue::Number(value) => { + serde_json::from_str(value).expect("canonical number") + } + CanonicalSourceValue::String(value) => json!(value), + CanonicalSourceValue::Array(items) => Value::Array( + items + .iter() + .map(|item| canonical_source_ledger(item, ledger)) + .collect(), + ), + CanonicalSourceValue::Object(items) => { + let mut fields = serde_json::Map::new(); + for (key, item) in items { + fields.insert(key.clone(), canonical_source_ledger(item, ledger)); + } + Value::Object(fields) + } + }; + assert!( + ledger + .insert(node.location.pointer.clone(), value.clone()) + .is_none() + ); + value +} + +#[derive(Debug, Deserialize)] +struct Manifest { + corpus_version: String, + matrix_version: String, + compatibility_impact: String, + documents: Vec, +} +#[derive(Debug, Deserialize)] +struct Document { + id: String, + file: String, + sha256: String, + canonical_digest: Option, + origin: String, + license: String, + specification_version: String, + classification: String, + expected_preview: Value, +} +fn manifest() -> Manifest { + serde_json::from_slice( + &fs::read(tests_root().join("corpus/manifest.json")).expect("manifest exists"), + ) + .expect("manifest JSON is valid") +} +fn normalize(source: &str) -> Result { + let source_digest = SourceDigest::parse(hex(source.as_bytes())).expect("sha256 is valid"); + normalize_verified_document(source, source_digest, &NormalizationConfig::default()) +} + +#[test] +fn ac_2_manifest_covers_fifty_provenanced_specs_with_exact_expectations() { + let manifest = manifest(); + assert_eq!(manifest.corpus_version, "1.0.3"); + assert_eq!(manifest.matrix_version, "1.0.2"); + assert!(!manifest.compatibility_impact.trim().is_empty()); + assert!(manifest.documents.len() >= 50); + let root = tests_root().join("corpus"); + let mut versions = std::collections::BTreeSet::new(); + let mut representative_count = 0; + for document in &manifest.documents { + assert!(!document.id.is_empty()); + assert!( + document.origin.starts_with("synthetic:"), + "{} lacks provenance", + document.id + ); + assert!( + document.license.contains("CC0"), + "{} lacks license", + document.id + ); + assert_eq!(document.sha256.len(), 64); + versions.insert(document.specification_version.as_str()); + let source = fs::read(root.join(&document.file)) + .unwrap_or_else(|e| panic!("{}: {e}", document.file)); + assert_eq!( + hex(&source), + document.sha256, + "checksum mismatch for {}", + document.file + ); + if let Ok(value) = serde_json::from_slice::(&source) { + let digest = hex(canonical_json(&value)); + assert_eq!( + document.canonical_digest.as_deref(), + Some(digest.as_str()), + "canonical digest mismatch for {}", + document.file + ); + } else { + assert!( + document.canonical_digest.is_none(), + "malformed JSON has no canonical digest" + ); + } + if document.classification == "representative" { + representative_count += 1; + let text = std::str::from_utf8(&source).expect("fixtures are UTF-8"); + let ir = + normalize(text).unwrap_or_else(|e| panic!("{} failed parser: {e}", document.file)); + validate_normalized_ir(&ir).expect("normalized IR has explicit source coverage"); + let preview = preview_from_ir(&ir); + let repeated_preview = + preview_from_ir(&normalize(text).expect("repeat normalization succeeds")); + assert_eq!( + serde_json::to_value(&preview).unwrap(), + serde_json::to_value(&repeated_preview).unwrap(), + "deterministic preview diff for {}:\nexpected={}\nactual={}", + document.file, + serde_json::to_string_pretty(&preview).unwrap(), + serde_json::to_string_pretty(&repeated_preview).unwrap(), + ); + let candidates = preview + .groups + .iter() + .flat_map(|g| &g.operations) + .collect::>(); + assert_eq!( + candidates.len(), + document.expected_preview["operation_count"] + .as_u64() + .unwrap() as usize, + "operation count in {}", + document.file + ); + assert_eq!( + candidates.len(), + 1, + "corpus fixtures are single-operation exact oracles" + ); + let expected = &document.expected_preview["operations"][0]; + let actual_candidate = serde_json::to_value(candidates[0]).unwrap(); + assert_eq!( + actual_candidate, + expected["candidate"], + "frozen candidate diff for {}:\nexpected={}\nactual={}", + document.file, + serde_json::to_string_pretty(&expected["candidate"]).unwrap(), + serde_json::to_string_pretty(&actual_candidate).unwrap(), + ); + let blocking_codes = candidates[0] + .findings + .iter() + .filter(|finding| { + finding.severity == crank_import::rest::ImportFindingSeverity::Error + }) + .map(|finding| finding.code.clone()) + .collect::>(); + assert_eq!(json!(blocking_codes), expected["blocker_codes"]); + assert_eq!( + blocking_codes.is_empty(), + expected["actionable"].as_bool().unwrap() + ); + assert_eq!( + hex(canonical_json(&actual_candidate)), + expected["candidate_digest"], + "candidate canonical digest in {}", + document.file + ); + assert_eq!( + hex(canonical_json(&serde_json::to_value(&preview).unwrap())), + document.expected_preview["canonical_preview_digest"], + "preview canonical digest in {}", + document.file + ); + let actual_preview = serde_json::to_value(&preview).unwrap(); + assert_eq!( + actual_preview, + document.expected_preview["canonical_preview"], + "frozen readable preview diff for {}:\nexpected={}\nactual={}", + document.file, + serde_json::to_string_pretty(&document.expected_preview["canonical_preview"]) + .unwrap(), + serde_json::to_string_pretty(&actual_preview).unwrap(), + ); + assert_eq!( + serde_json::to_value(candidates[0].method).unwrap().as_str(), + expected["method"].as_str() + ); + assert_eq!(candidates[0].path, expected["path"].as_str().unwrap()); + assert_eq!( + candidates[0].operation_id.as_deref(), + expected["operation_id"].as_str() + ); + assert!( + preview.findings.is_empty(), + "unexpected preview findings in {}: {:?}", + document.file, + preview.findings + ); + let mut actual_findings = candidates[0] + .findings + .iter() + .map(|f| f.code.as_str()) + .collect::>(); + let mut expected_findings = document.expected_preview["finding_codes"] + .as_array() + .unwrap() + .iter() + .map(|v| v.as_str().unwrap()) + .collect::>(); + actual_findings.sort_unstable(); + expected_findings.sort_unstable(); + assert_eq!( + actual_findings, expected_findings, + "finding codes in {}", + document.file + ); + } else { + assert_eq!(document.classification, "hostile"); + let text = std::str::from_utf8(&source).unwrap(); + let parsed = normalize(text); + assert_eq!( + parsed, + normalize(text), + "hostile parser result changed on deterministic rerun for {}", + document.file + ); + if [ + "hostile-empty.json", + "hostile-malformed.json", + "hostile-oversized.json", + "hostile-deep.json", + "hostile-aliases.yaml", + ] + .contains(&document.file.as_str()) + { + if [ + "hostile-oversized.json", + "hostile-deep.json", + "hostile-aliases.yaml", + ] + .contains(&document.file.as_str()) + { + assert!( + matches!(parsed, Err(ImportParseError::LimitExceeded)), + "{} must fail within configured bounds: {parsed:?}", + document.file + ); + } else { + assert!(parsed.is_err(), "{} must be rejected", document.file); + } + } else if document.file == "hostile-trace.json" { + let ir = parsed.expect("TRACE is reported instead of silently discarded"); + assert!( + ir.findings + .iter() + .any(|f| f.code == "unsupported_http_method") + ); + assert!(ir.coverage.iter().any(|c| c.construct_id.contains("trace") + && c.disposition == CoverageDisposition::Finding)); + } else if document.file == "hostile-xml.json" { + let ir = parsed.expect("XML is represented by an explicit finding"); + let preview = preview_from_ir(&ir); + let codes = preview + .groups + .iter() + .flat_map(|g| &g.operations) + .flat_map(|o| &o.findings) + .map(|f| f.code.as_str()) + .collect::>(); + assert!( + codes + .iter() + .any(|code| code.contains("xml") || code.contains("media")), + "XML findings: {codes:?}" + ); + } else if document.file == "hostile-secret.json" { + let ir = parsed.expect("secret-like examples remain inspectable"); + let evidence = serde_json::to_string(&preview_from_ir(&ir)).unwrap(); + assert!( + !evidence.contains("sk_test_corpus_secret_canary"), + "secret canary leaked into preview evidence" + ); + } else { + let ir = parsed.unwrap_or_else(|error| { + panic!( + "{} must have an explicit finding or bounded rejection: {error}", + document.file + ) + }); + validate_normalized_ir(&ir).expect("hostile construct coverage remains explicit"); + assert!( + !ir.coverage.is_empty(), + "{} has no construct ledger", + document.file + ); + let preview = preview_from_ir(&ir); + match document.file.as_str() { + "hostile-cycle.json" => { + assert_eq!( + ir.operations.len(), + 1, + "recursive schema must not drop the source operation" + ); + assert!( + ir.findings + .iter() + .chain(ir.operations.iter().flat_map(|op| &op.findings)) + .all(|finding| { + finding.severity + != crank_import::rest::ImportFindingSeverity::Error + }), + "bounded cycle policy must not yield an unexplained blocker: {:?} {:?}", + ir.findings, + ir.operations.iter().map(|op| &op.findings) + ); + assert!( + ir.unresolved_references.is_empty(), + "resolved recursion must not be reported as unresolvable: {:?}", + ir.unresolved_references + ); + let cycle_edge = |recursive: bool| { + ir.reference_graph.edges.iter().any(|edge| { + edge.recursive == recursive + && edge.source.location.pointer + == "/components/schemas/Node/properties/next/$ref" + && edge.target.location.pointer == "/components/schemas/Node" + }) + }; + assert!( + cycle_edge(false) && cycle_edge(true), + "Node.next must resolve through both bounded and recursive edges: {:?}", + ir.reference_graph.edges + ); + let response = ir.operations[0] + .response_variants + .iter() + .find(|variant| variant.status_code == 200) + .expect("200 response is retained"); + assert!( + matches!( + &response.schema, + Some(schema) if matches!( + &schema.kind, + crank_import::rest::NormalizedSchemaKind::Object { + properties, .. + } if properties.contains_key("next") + ) + ), + "recursive node schema must be projected: {:?}", + response.schema + ); + assert!( + ir.coverage.iter().any(|entry| { + entry.location.pointer + == "/components/schemas/Node/properties/next/properties/next" + && entry.disposition == CoverageDisposition::Mapped + }), + "bounded recursion must remain Mapped in the resolved source ledger: {:?}", + ir.coverage + ); + assert_eq!( + document.expected_preview["mapped_recursive_pointer"].as_str(), + Some("/components/schemas/Node/properties/next/properties/next") + ); + assert_eq!( + ir.findings + .iter() + .map(|f| (f.code.clone(), f.severity.clone())) + .collect::>(), + vec![( + "missing_servers".to_owned(), + crank_import::rest::ImportFindingSeverity::Warning + )], + "cycle fixture must expose only the exact bounded warning set: {:?}", + ir.findings + ); + assert_eq!( + document.expected_preview["operation_count"].as_u64(), + Some(1) + ); + assert_eq!( + document.expected_preview["recursive_edge"]["source"].as_str(), + Some("/components/schemas/Node/properties/next/$ref") + ); + assert_eq!( + document.expected_preview["recursive_edge"]["target"].as_str(), + Some("/components/schemas/Node") + ); + assert_eq!(document.expected_preview["blocker_findings"], json!([])); + assert_eq!( + document.expected_preview["unresolved_references"], + json!([]) + ); + assert_eq!( + document.expected_preview["warning_findings"], + json!([{"code":"missing_servers","severity":"Warning","operation_key":null}]) + ); + } + "hostile-external-ref.json" => assert!( + ir.findings.iter() + .chain(ir.operations.iter().flat_map(|op| &op.findings)) + .any(|finding| finding.code == "external_reference_disabled" + && finding.location.pointer == "/paths/~1hostile/get/responses/200/content/application~1json/schema/$ref"), + "external ref must be denied at its source: {:?}", + ir.findings + ), + "hostile-duplicate-ids.json" => assert_eq!( + ir.operations.len(), + 2, + "duplicate IDs must not drop a source operation" + ), + "hostile-composition-conflict.json" => { + assert_eq!( + ir.operations.len(), + 1, + "conflicting allOf must keep the source operation explicit" + ); + let conflict = ir.operations[0] + .findings + .iter() + .find(|finding| finding.code == "all_of_conflict") + .unwrap_or_else(|| { + panic!( + "allOf conflict must be named: {:?}", + ir.operations[0].findings + ) + }); + assert_eq!( + conflict.severity, + crank_import::rest::ImportFindingSeverity::Error, + "allOf conflict must block the candidate: {:?}", + conflict + ); + assert_eq!( + conflict.operation_key.as_deref(), + Some("GET /hostile"), + "conflict must belong to the affected candidate: {:?}", + conflict + ); + assert_eq!( + conflict.location.pointer, + "/paths/~1hostile/get/responses/200/content/application~1json/schema/allOf", + "conflict must point at the conflicting allOf: {:?}", + conflict + ); + assert!( + ir.coverage + .iter() + .any(|entry| { + entry.location + .pointer + == "/paths/~1hostile/get/responses/200/content/application~1json/schema/allOf" + }) + && ir + .operations[0] + .findings + .iter() + .any(|finding| finding.code == "all_of_conflict" + && finding.location.pointer + == "/paths/~1hostile/get/responses/200/content/application~1json/schema/allOf"), + "conflicting allOf must stay in the source ledger bound to the explicit finding: {:?}", + ir.coverage + ); + let response = ir.operations[0] + .response_variants + .iter() + .find(|variant| variant.status_code == 200) + .expect("200 response is retained"); + assert!( + matches!( + &response.schema, + Some(schema) if matches!( + &schema.kind, + crank_import::rest::NormalizedSchemaKind::Composition { + operator, variants + } if operator == "allOf" && variants.len() == 2 + ) + ), + "conflict branches must be preserved verbatim: {:?}", + response.schema + ); + assert_eq!( + ir.findings + .iter() + .map(|f| (f.code.clone(), f.severity.clone())) + .collect::>(), + vec![( + "missing_servers".to_owned(), + crank_import::rest::ImportFindingSeverity::Warning + )], + "composition conflict fixture must keep the exact warning set: {:?}", + ir.findings + ); + assert_eq!( + document.expected_preview["operation_count"].as_u64(), + Some(1) + ); + assert_eq!( + document.expected_preview["blocker_findings"], + json!([{"code":"all_of_conflict","severity":"Error", + "operation_key":"GET /hostile", + "location":"/paths/~1hostile/get/responses/200/content/application~1json/schema/allOf"}]) + ); + assert_eq!( + document.expected_preview["composition"], + json!({"operator":"allOf","branch_count":2}) + ); + assert_eq!( + document.expected_preview["warning_findings"], + json!([{"code":"missing_servers","severity":"Warning","operation_key":null}]) + ); + } + "hostile-security-scope.json" => { + assert_eq!( + ir.operations.len(), + 2, + "security-scope fixture must keep both candidates explicit: {:?}", + ir.operations.iter().map(|op| &op.key).collect::>() + ); + let requirements = ir + .findings + .iter() + .filter(|finding| finding.code == "unsupported_security_requirement") + .collect::>(); + assert_eq!( + requirements.len(), + 1, + "exactly the inherited requirement must produce a blocker: {:?}", + ir.findings + ); + let requirement = &requirements[0]; + assert_eq!( + requirement.severity, + crank_import::rest::ImportFindingSeverity::Error, + "security requirement must block its candidate: {:?}", + requirement + ); + assert_eq!( + requirement.operation_key.as_deref(), + Some("GET /secure"), + "blocker must belong only to the inherited secured candidate: {:?}", + requirement + ); + assert_eq!( + requirement.location.pointer, "/security/0", + "inherited requirement must point at the document root requirement: {:?}", + requirement + ); + let mut by_key = std::collections::BTreeMap::new(); + for group in &preview.groups { + for candidate in &group.operations { + by_key.insert(candidate.key.clone(), candidate); + } + } + let public = by_key.get("GET /public").expect("public candidate present"); + assert!( + public.findings.iter().all(|finding| finding.severity + != crank_import::rest::ImportFindingSeverity::Error), + "public operation with security: [] must stay actionable: {:?}", + public.findings + ); + assert!( + by_key + .get("GET /secure") + .expect("secured candidate present") + .findings + .iter() + .any(|finding| finding.code == "unsupported_security_requirement" + && finding.severity + == crank_import::rest::ImportFindingSeverity::Error), + "inherited requirement must block the secured candidate: {:?}", + by_key.get("GET /secure").unwrap().findings + ); + assert!( + preview + .findings + .iter() + .all(|finding| finding.operation_key.is_some()), + "no document-global blocker may be produced: {:?}", + preview.findings + ); + assert!( + ir.coverage + .iter() + .any(|entry| entry.location.pointer == "/security/0" + && entry.disposition == CoverageDisposition::Finding), + "inherited requirement must stay in the source ledger bound to the finding: {:?}", + ir.coverage + ); + let mut actual_operation_keys = preview + .groups + .iter() + .flat_map(|group| &group.operations) + .map(|op| op.key.clone()) + .collect::>(); + actual_operation_keys.sort(); + assert_eq!( + json!(actual_operation_keys), + document.expected_preview["operation_keys"], + "security-scope operation oracle for {}", + document.file + ); + let actual_blockers = requirements + .iter() + .map(|finding| { + json!({"code": finding.code.clone(), "severity": "Error", + "operation_key": finding.operation_key.clone(), + "location": finding.location.pointer.clone()}) + }) + .collect::>(); + assert_eq!( + actual_blockers, + document.expected_preview["blocker_findings"] + .as_array() + .unwrap() + .clone(), + "security-scope blocker oracle for {}: actual {actual_blockers:?}", + document.file + ); + let actual_warnings = ir + .findings + .iter() + .filter(|finding| { + finding.severity + == crank_import::rest::ImportFindingSeverity::Warning + }) + .map(|finding| { + json!({"code": finding.code.clone(), "severity": "Warning", + "operation_key": finding.operation_key.clone()}) + }) + .collect::>(); + assert_eq!( + actual_warnings, + document.expected_preview["warning_findings"] + .as_array() + .unwrap() + .clone(), + "security-scope warning oracle for {}: actual {actual_warnings:?}", + document.file + ); + } + _ => unreachable!("hostile fixture must have a dedicated expectation"), + } + } + } + } + // Exact file set: manifest rows are unique and every corpus data file is + // accounted exactly once, so duplicates or orphan fixtures cannot inflate + // or hide coverage. + let mut ids = std::collections::BTreeSet::new(); + let mut files = std::collections::BTreeSet::new(); + for document in &manifest.documents { + assert!( + ids.insert(document.id.clone()), + "duplicate manifest document id {}", + document.id + ); + assert!( + files.insert(document.file.clone()), + "duplicate manifest file {}", + document.file + ); + } + let expected_files = files + .into_iter() + .chain(std::iter::once("manifest.json".to_owned())) + .chain(std::iter::once("matrix.rs".to_owned())) + .collect::>(); + let actual_files = fs::read_dir(&root) + .expect("corpus directory exists") + .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned()) + .collect::>(); + assert_eq!( + actual_files, expected_files, + "corpus directory must equal the manifest file set exactly" + ); + assert_eq!(representative_count, 50); + assert!( + versions + .iter() + .any(|version| version.starts_with("OpenAPI 3.0")) + && versions + .iter() + .any(|version| version.starts_with("OpenAPI 3.1")) + && versions.contains("Swagger 2.0") + ); +} + +#[test] +fn ac_3_evidence_reports_actionable_denominator_exclusions_and_zero_silent_loss() { + let manifest = manifest(); + let mut denominator = 0_u64; + let mut actionable_count = 0_u64; + let mut operation_count = 0_u64; + let mut source_construct_count = 0_u64; + let mut covered_source_construct_count = 0_u64; + let mut semantic_coverage_count = 0_u64; + let mut silent_loss = Vec::new(); + let mut exclusions = Vec::new(); + let mut finding_count = 0_u64; + for document in &manifest.documents { + if document.classification != "representative" { + continue; + } + let source_bytes = fs::read(tests_root().join("corpus").join(&document.file)).unwrap(); + let source: Value = + serde_json::from_slice(&source_bytes).expect("representative corpus source is JSON"); + let mut raw_ledger = std::collections::BTreeMap::new(); + source_ledger(&source, "", &mut raw_ledger); + let source_text = std::str::from_utf8(&source_bytes).unwrap(); + let ir = normalize(source_text).unwrap(); + validate_normalized_ir(&ir).unwrap(); + let mut normalized_ledger = std::collections::BTreeMap::new(); + let _ = canonical_source_ledger(&ir.source_tree, &mut normalized_ledger); + assert_eq!( + normalized_ledger, raw_ledger, + "normalizer source-tree ledger differs from raw document for {}", + document.file + ); + source_construct_count += raw_ledger.len() as u64; + let coverage_by_id = ir + .coverage + .iter() + .map(|entry| (entry.construct_id.as_str(), entry)) + .collect::>(); + for pointer in raw_ledger.keys() { + let source_id = format!("source:{pointer}"); + match coverage_by_id.get(source_id.as_str()) { + Some(entry) + if entry.location.pointer == *pointer + && entry.disposition == CoverageDisposition::Mapped => + { + covered_source_construct_count += 1; + } + _ => silent_loss.push(json!({"document":document.id,"source_pointer":pointer,"coverage_id":source_id})), + } + } + let findings = ir + .findings + .iter() + .chain( + ir.operations + .iter() + .flat_map(|operation| &operation.findings), + ) + .collect::>(); + for entry in ir + .coverage + .iter() + .filter(|entry| !entry.construct_id.starts_with("source:")) + { + semantic_coverage_count += 1; + assert!( + raw_ledger.contains_key(&entry.location.pointer), + "coverage {} points outside raw source tree for {}", + entry.construct_id, + document.file + ); + match entry.disposition { + CoverageDisposition::Mapped => {} + CoverageDisposition::Finding => assert!( + findings + .iter() + .any(|finding| finding.construct_id == entry.construct_id + && finding.location == entry.location), + "finding coverage {} has no matching finding in {}", + entry.construct_id, + document.file + ), + } + } + for operation in &ir.operations { + denominator += 1; + operation_count += 1; + if operation + .findings + .iter() + .all(|f| f.severity != crank_import::rest::ImportFindingSeverity::Error) + { + actionable_count += 1; + } else { + exclusions.push(json!({"document":document.id,"operation":operation.key,"reason":"blocking_finding","findings":operation.findings.iter().map(|f| &f.code).collect::>()})); + } + } + finding_count += ir.findings.len() as u64; + } + assert!(denominator > 0); + assert!( + actionable_count * 100 >= denominator * 95, + "actionable {actionable_count}/{denominator}; exclusions={exclusions:?}" + ); + let silent_loss_count = silent_loss.len() as u64; + assert_eq!( + source_construct_count, covered_source_construct_count, + "independently enumerated raw source constructs lack coverage: {silent_loss:?}" + ); + let mut reversed_counts = (0_u64, 0_u64, 0_u64); + for document in manifest + .documents + .iter() + .rev() + .filter(|document| document.classification == "representative") + { + let source = fs::read_to_string(tests_root().join("corpus").join(&document.file)).unwrap(); + let ir = normalize(&source).unwrap(); + reversed_counts.0 += ir.operations.len() as u64; + reversed_counts.1 += ir + .operations + .iter() + .filter(|operation| { + operation.findings.iter().all(|finding| { + finding.severity != crank_import::rest::ImportFindingSeverity::Error + }) + }) + .count() as u64; + reversed_counts.2 += ir.findings.len() as u64; + } + assert_eq!( + reversed_counts, + (operation_count, actionable_count, finding_count), + "aggregate evidence must not depend on manifest order" + ); + let manifest_bytes = fs::read(tests_root().join("corpus/manifest.json")).unwrap(); + let manifest_digest = hex(&manifest_bytes); + let matrix_bytes = fs::read(tests_root().join("support-matrix.yaml")).unwrap(); + let matrix_digest = hex(&matrix_bytes); + let matrix_value: serde_yaml::Value = serde_yaml::from_slice(&matrix_bytes).unwrap(); + let matrix_row_count = matrix_value["constructs"].as_sequence().unwrap().len(); + let evidence_identity = hex(format!( + "{}\n{}\n{}\n{}", + manifest.corpus_version, manifest.matrix_version, manifest_digest, matrix_digest + )); + let mut evidence = json!({ + "evidence_version":"1.0.0", "corpus_version":manifest.corpus_version, "matrix_version":manifest.matrix_version, + "evidence_identity":evidence_identity, + "content_digest_algorithm":"sha256", + "content_digest_definition":"SHA-256 of compact key-sorted JSON before the content_digest field is added.", + "manifest_digest":manifest_digest, + "matrix_digest":matrix_digest, + "denominator":denominator, "actionable_count":actionable_count, "exclusions":exclusions, + "raw_counts":{"documents":manifest.documents.len(),"representative_operations":operation_count,"findings":finding_count,"source_constructs":source_construct_count,"covered_source_constructs":covered_source_construct_count,"semantic_coverage_entries":semantic_coverage_count}, + "matrix_contract":{"construct_rows":matrix_row_count,"semantic_probes":"AC-1 runs a generated normalizer probe for every matrix row, including every 2xx status in all three formats."}, + "uncovered_source_constructs":silent_loss, + "silent_loss_count":silent_loss_count, + "method":"real normalize_verified_document + preview_from_ir; every NormalizedIr passed validate_normalized_ir" + }); + let content_digest = hex(canonical_json(&evidence)); + evidence["content_digest"] = json!(content_digest); + let artifact = Path::new(env!("CARGO_MANIFEST_DIR")).join(format!( + "target/openapi-corpus/evidence-{evidence_identity}.json" + )); + let target_dir = artifact.parent().unwrap(); + fs::create_dir_all(target_dir).unwrap(); + let bytes = serde_json::to_vec_pretty(&evidence).unwrap(); + // Each process needs its own temp file: concurrent corpus runs must not + // truncate each other's pending evidence before atomic publication. + let mut nonce = 0u32; + let (publish, mut file) = loop { + let path = target_dir.join(format!( + "evidence.json.tmp-{}-{}-{nonce}", + &evidence_identity[..16], + std::process::id() + )); + match fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(&path) + { + Ok(file) => break (path, file), + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists && nonce < 1024 => { + nonce += 1; + } + Err(error) => panic!( + "cannot create evidence temp file {}: {error}", + path.display() + ), + } + }; + { + use std::io::Write; + file.write_all(&bytes).unwrap(); + file.sync_all().unwrap(); + } + // hard_link fails atomically when the final identity already exists. + // Rename would silently overwrite after an exists-check race, while + // create_new on the final path would expose partial bytes after a crash. + let published = match fs::hard_link(&publish, &artifact) { + Ok(()) => true, + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => false, + Err(error) => panic!( + "cannot publish immutable evidence artifact {}: {error}", + artifact.display() + ), + }; + fs::remove_file(&publish).ok(); + if !published { + let existing = fs::read(&artifact).unwrap(); + assert_eq!( + existing, + bytes, + "immutable evidence identity {evidence_identity} already has conflicting contents at {}", + artifact.display() + ); + } + if let Ok(directory) = fs::File::open(target_dir) { + let _ = directory.sync_all(); + } + let reread: Value = serde_json::from_slice(&fs::read(artifact).unwrap()).unwrap(); + assert_eq!(reread, evidence); + assert_eq!(reread["silent_loss_count"], 0); + assert_eq!(source_construct_count, covered_source_construct_count); + assert_eq!(reread["denominator"], denominator); + assert_eq!(reread["actionable_count"], actionable_count); +} diff --git a/crates/crank-import/tests/corpus/hostile-aliases.yaml b/crates/crank-import/tests/corpus/hostile-aliases.yaml new file mode 100644 index 0000000..ef279bf --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-aliases.yaml @@ -0,0 +1,5 @@ +openapi: 3.1.0 +info: {title: Aliases, version: 1} +paths: {} +x-anchor: &anchor {type: string} +x-aliases: [*anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor, *anchor] diff --git a/crates/crank-import/tests/corpus/hostile-composition-conflict.json b/crates/crank-import/tests/corpus/hostile-composition-conflict.json new file mode 100644 index 0000000..5b68531 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-composition-conflict.json @@ -0,0 +1,43 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Hostile generated", + "version": "1" + }, + "paths": { + "/hostile": { + "get": { + "operationId": "hostileOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/json": { + "schema": { + "allOf": [ + { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + { + "type": "object", + "properties": { + "id": { + "type": "integer" + } + } + } + ] + } + } + } + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-cycle.json b/crates/crank-import/tests/corpus/hostile-cycle.json new file mode 100644 index 0000000..4f0f07d --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-cycle.json @@ -0,0 +1,38 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Hostile generated", + "version": "1" + }, + "paths": { + "/hostile": { + "get": { + "operationId": "hostileOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Node" + } + } + } + } + } + } + } + }, + "components": { + "schemas": { + "Node": { + "type": "object", + "properties": { + "next": { + "$ref": "#/components/schemas/Node" + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-deep.json b/crates/crank-import/tests/corpus/hostile-deep.json new file mode 100644 index 0000000..b8d0139 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-deep.json @@ -0,0 +1 @@ +{"openapi":"3.1.0","info":{"title":"Hostile generated","version":"1"},"paths":{"/hostile":{"get":{"operationId":"hostileOperation","responses":{"200":{"description":"ok","content":{"application/json":{"schema":{"type":"object"}}}}}}}},"components":{"schemas":{"Deep":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"array","items":{"type":"string"}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} diff --git a/crates/crank-import/tests/corpus/hostile-duplicate-ids.json b/crates/crank-import/tests/corpus/hostile-duplicate-ids.json new file mode 100644 index 0000000..321ad3f --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-duplicate-ids.json @@ -0,0 +1,36 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Hostile generated", + "version": "1" + }, + "paths": { + "/hostile": { + "get": { + "operationId": "hostileOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/json": { + "schema": { + "$ref": "https://external.example.test/schema.json" + } + } + } + } + } + } + }, + "/other": { + "post": { + "operationId": "hostileOperation", + "responses": { + "200": { + "description": "ok" + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-empty.json b/crates/crank-import/tests/corpus/hostile-empty.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-empty.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/crates/crank-import/tests/corpus/hostile-external-ref.json b/crates/crank-import/tests/corpus/hostile-external-ref.json new file mode 100644 index 0000000..975ded4 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-external-ref.json @@ -0,0 +1,26 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Hostile generated", + "version": "1" + }, + "paths": { + "/hostile": { + "get": { + "operationId": "hostileOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/json": { + "schema": { + "$ref": "https://external.example.test/schema.json" + } + } + } + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-malformed.json b/crates/crank-import/tests/corpus/hostile-malformed.json new file mode 100644 index 0000000..b4a79a2 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-malformed.json @@ -0,0 +1 @@ +{"openapi": diff --git a/crates/crank-import/tests/corpus/hostile-oversized.json b/crates/crank-import/tests/corpus/hostile-oversized.json new file mode 100644 index 0000000..f144b3a --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-oversized.json @@ -0,0 +1,12 @@ +{ + "openapi": "3.1.0", + "info": {"title": "Hostile generated", "version": "1"}, + "paths": {"/hostile": {"get": {"operationId": "hostileOperation", "responses": {"200": {"description": "ok", "content": {"application/json": {"schema": {"type": "string"}}}}}}}}, + "x-padding-0": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-1": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-2": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-3": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-4": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-5": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "x-padding-6": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +} diff --git a/crates/crank-import/tests/corpus/hostile-secret.json b/crates/crank-import/tests/corpus/hostile-secret.json new file mode 100644 index 0000000..a9aac79 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-secret.json @@ -0,0 +1,32 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Secret hostile", + "version": "1" + }, + "paths": { + "/secret": { + "get": { + "operationId": "secretOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/json": { + "schema": { + "type": "object" + } + } + } + } + }, + "x-example": "sk_test_corpus_secret_canary" + } + } + }, + "servers": [ + { + "url": "https://api.example.test" + } + ] +} diff --git a/crates/crank-import/tests/corpus/hostile-security-scope.json b/crates/crank-import/tests/corpus/hostile-security-scope.json new file mode 100644 index 0000000..34acb78 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-security-scope.json @@ -0,0 +1,48 @@ +{ + "openapi": "3.0.3", + "info": { + "title": "Hostile security scope", + "version": "1" + }, + "servers": [ + { + "url": "https://corpus.example.test" + } + ], + "security": [ + { + "corpusProbe": [] + } + ], + "components": { + "securitySchemes": { + "corpusProbe": { + "type": "http", + "scheme": "basic" + } + } + }, + "paths": { + "/public": { + "get": { + "operationId": "publicProbe", + "security": [], + "responses": { + "200": { + "description": "ok" + } + } + } + }, + "/secure": { + "get": { + "operationId": "secureProbe", + "responses": { + "200": { + "description": "ok" + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-trace.json b/crates/crank-import/tests/corpus/hostile-trace.json new file mode 100644 index 0000000..a5391fe --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-trace.json @@ -0,0 +1,18 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "TRACE hostile", + "version": "1" + }, + "paths": { + "/trace": { + "trace": { + "responses": { + "200": { + "description": "unsupported" + } + } + } + } + } +} diff --git a/crates/crank-import/tests/corpus/hostile-xml.json b/crates/crank-import/tests/corpus/hostile-xml.json new file mode 100644 index 0000000..e8078d8 --- /dev/null +++ b/crates/crank-import/tests/corpus/hostile-xml.json @@ -0,0 +1,31 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "XML hostile", + "version": "1" + }, + "paths": { + "/xml": { + "get": { + "operationId": "xmlOperation", + "responses": { + "200": { + "description": "ok", + "content": { + "application/xml": { + "schema": { + "type": "string" + } + } + } + } + } + } + } + }, + "servers": [ + { + "url": "https://api.example.test" + } + ] +} diff --git a/crates/crank-import/tests/corpus/manifest.json b/crates/crank-import/tests/corpus/manifest.json new file mode 100644 index 0000000..4e74716 --- /dev/null +++ b/crates/crank-import/tests/corpus/manifest.json @@ -0,0 +1,14420 @@ +{ + "corpus_version": "1.0.3", + "matrix_version": "1.0.2", + "digest_algorithm": "sha256", + "canonical_digest_definition": "SHA-256 of compact JSON with lexicographically ordered keys; null for malformed JSON", + "documents": [ + { + "id": "rep-00", + "file": "representative-00.json", + "sha256": "a8e84701e08750fef5adbcc6ae0e8341b2cdb3b8fc6100f81d4bb5a38aa222c0", + "canonical_digest": "8b3b7206da3930cd4b3447002a3e7580dc5a57283ebd1568d985251c82859a5b", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/0", + "operation_id": "corpusOperation00", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 00", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 00", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p00", + "target": "$.request.query.p00" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p00": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation00", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/0", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 00", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 00" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/0", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/0", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/0", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/0", + "method": "GET", + "operation_id": "corpusOperation00", + "output_fields": 1, + "path": "/items/0", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 00", + "suggested_name": "corpus_operation00" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "a28f86380d510df8d46018cd3767d445c7450bea42563702de1b9c6ecaac0f53" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "df4c7068366ad3bcecb756f3553128eec9e200557d2500df21c6fccc7bcef7fe", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 00", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 00", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p00", + "target": "$.request.query.p00" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p00": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation00", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/0", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 00", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 00" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/0", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/0", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/0", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/0", + "method": "GET", + "operation_id": "corpusOperation00", + "output_fields": 1, + "path": "/items/0", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 00", + "suggested_name": "corpus_operation00" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 00", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-01", + "file": "representative-01.json", + "sha256": "0f80248628bef2e17896fa44f6e7c12ddcd979f94e88911117083b92b0b772ad", + "canonical_digest": "6f0c11966664ebe46373a3fbf175e16899482d3ab5c0ef2a4db3a1e0ea2c1809", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/{p01}", + "operation_id": "corpusOperation01", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 01", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 01", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p01", + "target": "$.request.path.p01" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p01": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation01", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/{p01}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 01", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 01" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/{p01}", + "method": "POST", + "operation_id": "corpusOperation01", + "output_fields": 1, + "path": "/items/{p01}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 01", + "suggested_name": "corpus_operation01" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "5988988cb6e412ab6852e253f559358c4d064ee65f60254ca42fe74025fa3c03" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "07e209a48e95e864137be08e89f28228c66f04ade44fbb1ae33d1e27cced170f", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 01", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 01", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p01", + "target": "$.request.path.p01" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p01": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation01", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/{p01}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 01", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 01" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/{p01}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/{p01}", + "method": "POST", + "operation_id": "corpusOperation01", + "output_fields": 1, + "path": "/items/{p01}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 01", + "suggested_name": "corpus_operation01" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 01", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-02", + "file": "representative-02.json", + "sha256": "3afda2ee298e08f5279979a3df3181d5606f3b15201a26fe6375855c3a5c5b7b", + "canonical_digest": "be75a434d7e0db1b5d58a6d671e4437f47344a019b1c697984acdd952aae3c8f", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/2", + "operation_id": "corpusOperation02", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 02", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 02", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p02", + "target": "$.request.headers.p02" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p02": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation02", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/2", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 02", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 02" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/2", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/2", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/2", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/2", + "method": "PUT", + "operation_id": "corpusOperation02", + "output_fields": 1, + "path": "/items/2", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 02", + "suggested_name": "corpus_operation02" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "ab005a5b770e045b69e106df6723aa09c2fc1ad7bba7bab29bf77aa0f2519f5b" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "421c76a662b054f31be9e2749cb6e27a89e8648b9493bc171c3b70b934b3413b", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 02", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 02", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p02", + "target": "$.request.headers.p02" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p02": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation02", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/2", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 02", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 02" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/2", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/2", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/2", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/2", + "method": "PUT", + "operation_id": "corpusOperation02", + "output_fields": 1, + "path": "/items/2", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 02", + "suggested_name": "corpus_operation02" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 02", + "version": "2.0" + } + } + } + }, + { + "id": "rep-03", + "file": "representative-03.json", + "sha256": "30729f295f999512173010ae0572bc8516133120cf40e3830633f717ee356985", + "canonical_digest": "d3fbeb735d0cf4c4b5a748a34ea0def45839f4e28cb214f218277f322a49340b", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/3", + "operation_id": "corpusOperation03", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 03", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 03", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p03", + "target": "$.request.cookies.p03" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p03": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation03", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/3", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 03", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 03" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/3", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/3", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/3", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/3", + "method": "PATCH", + "operation_id": "corpusOperation03", + "output_fields": 1, + "path": "/items/3", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 03", + "suggested_name": "corpus_operation03" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "9cf76cd4e95147f53f47df5dfedd1ecf355657f923a9b99e6c67412057864497" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "4f457e379c47a5a729beec4ab176644396da1da3c818c1a31ff133e28e3ca40b", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 03", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 03", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p03", + "target": "$.request.cookies.p03" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p03": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation03", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/3", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 03", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 03" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/3", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/3", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/3", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/3", + "method": "PATCH", + "operation_id": "corpusOperation03", + "output_fields": 1, + "path": "/items/3", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 03", + "suggested_name": "corpus_operation03" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 03", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-04", + "file": "representative-04.json", + "sha256": "b8768a80266f80ddbd7a0364cca2d6c229a2df084597ebf650dc43d36a7464d8", + "canonical_digest": "565f07ac02fc6a6ba63f0356cba1e4c50bd8df12f203f23416762eede585dde6", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/4", + "operation_id": "corpusOperation04", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 04", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 04", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p04", + "target": "$.request.query.p04" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p04": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation04", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/4", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 04", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 04" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/4", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/4", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/4", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/4", + "method": "DELETE", + "operation_id": "corpusOperation04", + "output_fields": 1, + "path": "/items/4", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 04", + "suggested_name": "corpus_operation04" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "7218c206fc70f05c45577ad776d0d3e0b921b5aa55c6bd9289584936824be8a6" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "74e51e9f9d45beca41ed66e2551500b9cb5f79d735fa5e75bf581ad6e582b6a6", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 04", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 04", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p04", + "target": "$.request.query.p04" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p04": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation04", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/4", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 04", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 04" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/4", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/4", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/4", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/4", + "method": "DELETE", + "operation_id": "corpusOperation04", + "output_fields": 1, + "path": "/items/4", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 04", + "suggested_name": "corpus_operation04" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 04", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-05", + "file": "representative-05.json", + "sha256": "59ed9af86a5af47a0b17580e73755cb2532a7227d183554357ad6dbf93f4b21f", + "canonical_digest": "201bfee79e759ab0147f8e25b08302f2bc407a6d3c21a498a1dbab3321e38075", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/{p05}", + "operation_id": "corpusOperation05", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 05", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 05", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p05", + "target": "$.request.path.p05" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p05": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation05", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/{p05}", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 05", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 05" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/{p05}", + "method": "HEAD", + "operation_id": "corpusOperation05", + "output_fields": 0, + "path": "/items/{p05}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 05", + "suggested_name": "corpus_operation05" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "56d427fad224c749ff27ff7ef34e921087ec35e72220bea16bc21a94e87c2335" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "fc92474b58c11b7699420c51cc3fb4bd23e9cb49b91b8bc720039adb25d43232", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 05", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 05", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p05", + "target": "$.request.path.p05" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p05": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation05", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/{p05}", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 05", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 05" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/{p05}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/{p05}", + "method": "HEAD", + "operation_id": "corpusOperation05", + "output_fields": 0, + "path": "/items/{p05}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 05", + "suggested_name": "corpus_operation05" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 05", + "version": "2.0" + } + } + } + }, + { + "id": "rep-06", + "file": "representative-06.json", + "sha256": "33e51175dddcff1db2e0181d1ce668e5b15b911db1fbcdfe1f511d76182c79c1", + "canonical_digest": "f113ef8f17ed25ab368fcade4d5407d7de7af9ebe543b4c4ec9f49928c615d09", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/6", + "operation_id": "corpusOperation06", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 06", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 06", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p06", + "target": "$.request.headers.p06" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p06": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation06", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/6", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 06", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 06" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/6", + "method": "OPTIONS", + "operation_id": "corpusOperation06", + "output_fields": 1, + "path": "/items/6", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 06", + "suggested_name": "corpus_operation06" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "d1648614cdcbbec99c607dc54c678fafb15f15700daaa599c8cc58caa8128fc0" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "92bc8783bb53e7adb550278b2e1a0855534dbe105c80a0f6c8972dc2d62d1d3f", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 06", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 06", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p06", + "target": "$.request.headers.p06" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p06": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation06", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/6", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 06", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 06" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/6", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/6", + "method": "OPTIONS", + "operation_id": "corpusOperation06", + "output_fields": 1, + "path": "/items/6", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 06", + "suggested_name": "corpus_operation06" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 06", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-07", + "file": "representative-07.json", + "sha256": "69748e81d96e393314f00123129c6ed60102577affd82ac848e318383f0839e1", + "canonical_digest": "49c4710d9f183c408ad519e87ba3f1a815bc4bded067e033292d4da5177fe3cc", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/7", + "operation_id": "corpusOperation07", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 07", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 07", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p07", + "target": "$.request.cookies.p07" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p07": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation07", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/7", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 07", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 07" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/7", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/7", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/7", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/7", + "method": "GET", + "operation_id": "corpusOperation07", + "output_fields": 1, + "path": "/items/7", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 07", + "suggested_name": "corpus_operation07" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "aa444c9def0b6082b3176a5f0d038dfad0f08ea03dfb2f2f40617f84ba138d38" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "b2caa897c0b8f6e13d3305909baf57bd5f855f5c3cee0c850d7f99ac60334bbb", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 07", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 07", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p07", + "target": "$.request.cookies.p07" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p07": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation07", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/7", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 07", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 07" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/7", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/7", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/7", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/7", + "method": "GET", + "operation_id": "corpusOperation07", + "output_fields": 1, + "path": "/items/7", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 07", + "suggested_name": "corpus_operation07" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 07", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-08", + "file": "representative-08.json", + "sha256": "11bd5d0d7548c7253cff2ff273d0fae61b6a8940f0229742c7cf44baa1909a69", + "canonical_digest": "531402e8e128476dbde20b8b33a827ebd9eb718d6a1aaefe726970f9df5088a9", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/8", + "operation_id": "corpusOperation08", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 08", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 08", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p08", + "target": "$.request.query.p08" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p08": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation08", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/8", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 08", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 08" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/8", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/8", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/8", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "POST /items/8", + "method": "POST", + "operation_id": "corpusOperation08", + "output_fields": 1, + "path": "/items/8", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 08", + "suggested_name": "corpus_operation08" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "1fdc42135574b4441687c29eda605e3b0968ff5e81d57036cc9882d76bf2863a" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "31c5b656c35c67ddac77dbd50d98ec4df589b750cc349df7c95b5095affe6d17", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 08", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 08", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p08", + "target": "$.request.query.p08" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p08": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation08", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/8", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 08", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 08" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/8", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/8", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/8", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "POST /items/8", + "method": "POST", + "operation_id": "corpusOperation08", + "output_fields": 1, + "path": "/items/8", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 08", + "suggested_name": "corpus_operation08" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 08", + "version": "2.0" + } + } + } + }, + { + "id": "rep-09", + "file": "representative-09.json", + "sha256": "948fc7a26da9b5b208439fe63fffff00dfc1c503fd788a81b7b00d7677e9a915", + "canonical_digest": "104e4324e17551fd637d72387b515c8b4394ed0acf4efb931fbcfca1ad33c001", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/{p09}", + "operation_id": "corpusOperation09", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 09", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 09", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p09", + "target": "$.request.path.p09" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p09": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation09", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/{p09}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 09", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 09" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/{p09}", + "method": "PUT", + "operation_id": "corpusOperation09", + "output_fields": 1, + "path": "/items/{p09}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 09", + "suggested_name": "corpus_operation09" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "e2c1a893420f728d047f9d45c79422508c4f1145c446000589286d0e48a10c94" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "6e03a5d02c10c559f99d92ab33e18e03fe5fd98db11b28392c9acf5d84d735a6", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 09", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 09", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p09", + "target": "$.request.path.p09" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p09": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation09", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/{p09}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 09", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 09" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/{p09}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/{p09}", + "method": "PUT", + "operation_id": "corpusOperation09", + "output_fields": 1, + "path": "/items/{p09}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 09", + "suggested_name": "corpus_operation09" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 09", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-10", + "file": "representative-10.json", + "sha256": "ca78eb0bc6f6998d3aabc09bc8fb54c850fe7f1721b425163da99d71e2fe5761", + "canonical_digest": "fcd89d029f22285de06d7ad0ac1659cb034ee60ce0c457a538bdd43be4278928", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/10", + "operation_id": "corpusOperation10", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 10", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 10", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p10", + "target": "$.request.headers.p10" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p10": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation10", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/10", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 10", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 10" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/10", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/10", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/10", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/10", + "method": "PATCH", + "operation_id": "corpusOperation10", + "output_fields": 1, + "path": "/items/10", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 10", + "suggested_name": "corpus_operation10" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "55afdf9db0d37a4869b71753e8d8f616c21eb2357658b36955a4270b3b3624db" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "7cd9de4a739474521ad0fc4cf5ed121a352d8f5a38cad50833ecc9bb2e176009", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 10", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 10", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p10", + "target": "$.request.headers.p10" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p10": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation10", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/10", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 10", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 10" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/10", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/10", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/10", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/10", + "method": "PATCH", + "operation_id": "corpusOperation10", + "output_fields": 1, + "path": "/items/10", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 10", + "suggested_name": "corpus_operation10" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 10", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-11", + "file": "representative-11.json", + "sha256": "980eee3cf0c769b6cf4982a61cb886079db00ce09ca11558c4583b54d19bda01", + "canonical_digest": "6c2bf27c95b93401dff6e5e0cd9a0c329195772b9b43c0f71f5343511d339c60", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/11", + "operation_id": "corpusOperation11", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 11", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 11", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p11", + "target": "$.request.headers.p11" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p11": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation11", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/11", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 11", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 11" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/11", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/11", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/11", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/11", + "method": "DELETE", + "operation_id": "corpusOperation11", + "output_fields": 1, + "path": "/items/11", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 11", + "suggested_name": "corpus_operation11" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "00fb4c9d745090be6cac2912dcdbe7bcb68a2863712fad5a7158efae3106924c" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "da05134ab7b9d72b2ea4ee20e520b4ed426573c1d78d3eb88551a264d3b1004d", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 11", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 11", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p11", + "target": "$.request.headers.p11" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p11": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation11", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/11", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 11", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 11" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/11", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/11", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/11", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/11", + "method": "DELETE", + "operation_id": "corpusOperation11", + "output_fields": 1, + "path": "/items/11", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 11", + "suggested_name": "corpus_operation11" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 11", + "version": "2.0" + } + } + } + }, + { + "id": "rep-12", + "file": "representative-12.json", + "sha256": "16254d5a72364229703cdaf5b61b6e9168c3b4ce43dc16662e1ef6aa91285414", + "canonical_digest": "231275deaf1f6bda870e25926713be784c4b2e6df8decf019079894409410b84", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/12", + "operation_id": "corpusOperation12", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 12", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 12", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p12", + "target": "$.request.query.p12" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p12": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation12", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/12", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 12", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 12" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/12", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/12", + "method": "HEAD", + "operation_id": "corpusOperation12", + "output_fields": 0, + "path": "/items/12", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 12", + "suggested_name": "corpus_operation12" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "2ac514cb9fc89bf6a45b6296db5ec26c8775209f72b57bcc3cd83b015a49eba4" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "95daac5f79ee78cfeb2aadbcfc7ae83a87fb6299e7d98711d841a18fff3da381", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 12", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 12", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p12", + "target": "$.request.query.p12" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p12": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation12", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/12", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 12", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 12" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/12", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/12", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/12", + "method": "HEAD", + "operation_id": "corpusOperation12", + "output_fields": 0, + "path": "/items/12", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 12", + "suggested_name": "corpus_operation12" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 12", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-13", + "file": "representative-13.json", + "sha256": "a5e161d898394e99272965eb9b30794dbed2293d4996f11a096a2702c507ef6c", + "canonical_digest": "50a544a935677c9f08406594e0c1f304887f6ef9cb4c4ae97c158eeadd8dc4dc", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/{p13}", + "operation_id": "corpusOperation13", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 13", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 13", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p13", + "target": "$.request.path.p13" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p13": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation13", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/{p13}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 13", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 13" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/{p13}", + "method": "OPTIONS", + "operation_id": "corpusOperation13", + "output_fields": 1, + "path": "/items/{p13}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 13", + "suggested_name": "corpus_operation13" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "896a31e5034b25725c557d5303f0603d34b151ca8e0a3bd003ab73dd9039d7f1" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "228e5a47701346c19986be6f6d4cc9c72c802e6c9bc61c296d46aa1fb6bf5d78", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 13", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 13", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p13", + "target": "$.request.path.p13" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p13": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation13", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/{p13}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 13", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 13" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/{p13}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/{p13}", + "method": "OPTIONS", + "operation_id": "corpusOperation13", + "output_fields": 1, + "path": "/items/{p13}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 13", + "suggested_name": "corpus_operation13" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 13", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-14", + "file": "representative-14.json", + "sha256": "0356a40a8f459128a06ac482e0c0c8d52460b4cb919590d9a25e5d9a109564d1", + "canonical_digest": "ff9a0a9705967ed011811ac7a940a15bb37fe96cb5219c4547412663bb3e27ae", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/14", + "operation_id": "corpusOperation14", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 14", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 14", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p14", + "target": "$.request.headers.p14" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p14": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation14", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/14", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 14", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 14" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/14", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/14", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/14", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/14", + "method": "GET", + "operation_id": "corpusOperation14", + "output_fields": 1, + "path": "/items/14", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 14", + "suggested_name": "corpus_operation14" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "e51a6adfa2e9dae225e7a8a0e8af3dffb4e16875cf4152ab75d10d354ce0f3d6" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "0decad1890ca88c5de98b1f7ade621a4b479b7c99662cdd715fd7876f4c7bcf1", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 14", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 14", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p14", + "target": "$.request.headers.p14" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p14": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation14", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/14", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 14", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 14" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/14", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/14", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/14", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/14", + "method": "GET", + "operation_id": "corpusOperation14", + "output_fields": 1, + "path": "/items/14", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 14", + "suggested_name": "corpus_operation14" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 14", + "version": "2.0" + } + } + } + }, + { + "id": "rep-15", + "file": "representative-15.json", + "sha256": "b8fde33d4265c2449465edf3d2d6b816eb9143e2d32b13bd25c094dce0a6993e", + "canonical_digest": "b579168cbebe23326e35e40a2a4548fb317825851d9b476294109a4854489587", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/15", + "operation_id": "corpusOperation15", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 15", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 15", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p15", + "target": "$.request.cookies.p15" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p15": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation15", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/15", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 15", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 15" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/15", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/15", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/15", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/15", + "method": "POST", + "operation_id": "corpusOperation15", + "output_fields": 1, + "path": "/items/15", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 15", + "suggested_name": "corpus_operation15" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "fc45211e445a1be1af69caec56a404912e46bbc4b9b0f5438b9df0823d14808e" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "9399dc82788787382104e3193c35ec0638d9b513d2f346262a001f82ae59fb0b", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 15", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 15", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p15", + "target": "$.request.cookies.p15" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p15": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation15", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/15", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 15", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 15" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/15", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/15", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/15", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/15", + "method": "POST", + "operation_id": "corpusOperation15", + "output_fields": 1, + "path": "/items/15", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 15", + "suggested_name": "corpus_operation15" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 15", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-16", + "file": "representative-16.json", + "sha256": "9ec04bb01c04ca65c9bb314a09f340f4e4e3c531656c32429efc732a72b540b6", + "canonical_digest": "29ebb860b71eb95834a68d28c6fe7822ab7baf3f98fe53e99f10606a66deeee2", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/16", + "operation_id": "corpusOperation16", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 16", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 16", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p16", + "target": "$.request.query.p16" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p16": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation16", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/16", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 16", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 16" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/16", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/16", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/16", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/16", + "method": "PUT", + "operation_id": "corpusOperation16", + "output_fields": 1, + "path": "/items/16", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 16", + "suggested_name": "corpus_operation16" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "221b6b0a2113fae03334cdb49f557fa21ce605682fe622bf14e5033d738f492b" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "585b949c63d44c51428e3fc3e048e34b4186ec2c3c438e08d5f026517f755e06", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 16", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 16", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p16", + "target": "$.request.query.p16" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p16": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation16", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/16", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 16", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 16" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/16", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/16", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/16", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/16", + "method": "PUT", + "operation_id": "corpusOperation16", + "output_fields": 1, + "path": "/items/16", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 16", + "suggested_name": "corpus_operation16" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 16", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-17", + "file": "representative-17.json", + "sha256": "4e9c7c16873ca0d5bcf737c06b81eb31e4b643a4ca4493846cdbb5e385382d16", + "canonical_digest": "346ea375d8963acb1b03b33267c7e807e2a1ad55dc23cd15363f097e6778e44b", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/{p17}", + "operation_id": "corpusOperation17", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 17", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 17", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p17", + "target": "$.request.path.p17" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p17": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation17", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/{p17}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 17", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 17" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PATCH /items/{p17}", + "method": "PATCH", + "operation_id": "corpusOperation17", + "output_fields": 1, + "path": "/items/{p17}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 17", + "suggested_name": "corpus_operation17" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "980e6cad722b7b7c5a59c9c91071e11319ba3d89bef9d6d57886355b7112a1e4" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "822d40bcfdda3a67c4e5e23a1fb1f32ff815f706f3caf4f7b1ecbe00f907c055", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 17", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 17", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p17", + "target": "$.request.path.p17" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p17": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation17", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/{p17}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 17", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 17" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/{p17}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PATCH /items/{p17}", + "method": "PATCH", + "operation_id": "corpusOperation17", + "output_fields": 1, + "path": "/items/{p17}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 17", + "suggested_name": "corpus_operation17" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 17", + "version": "2.0" + } + } + } + }, + { + "id": "rep-18", + "file": "representative-18.json", + "sha256": "42cb88fef4bf85cb33b2a62a9e78e185857b5b881aaede01f29c071de161b22d", + "canonical_digest": "553546cf62e3521d51ea585a85ace95bd1450803ceb02b924f064d9be745a813", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/18", + "operation_id": "corpusOperation18", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 18", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 18", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p18", + "target": "$.request.headers.p18" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p18": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation18", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/18", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 18", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 18" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/18", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/18", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/18", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/18", + "method": "DELETE", + "operation_id": "corpusOperation18", + "output_fields": 1, + "path": "/items/18", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 18", + "suggested_name": "corpus_operation18" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "6388c4d905b7cd2be74a86db43165943913c21b2e25d435b7e758e7a5f5b2273" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "233384b489f99d9ec8df78def0fa29ef18c3a5a37047195d404d32c41a20cd7b", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 18", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 18", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p18", + "target": "$.request.headers.p18" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p18": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation18", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/18", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 18", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 18" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/18", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/18", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/18", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/18", + "method": "DELETE", + "operation_id": "corpusOperation18", + "output_fields": 1, + "path": "/items/18", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 18", + "suggested_name": "corpus_operation18" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 18", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-19", + "file": "representative-19.json", + "sha256": "779cb787f5ee44230625c3d95bb6c08a9477adb324f51beeb3120cfb80aee440", + "canonical_digest": "f9453f2f8978cf1eec54083dca3ac65ec6670b2d49f38669f5e8094d7cfbd2f7", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/19", + "operation_id": "corpusOperation19", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 19", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 19", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p19", + "target": "$.request.cookies.p19" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p19": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation19", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/19", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 19", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 19" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/19", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/19", + "method": "HEAD", + "operation_id": "corpusOperation19", + "output_fields": 0, + "path": "/items/19", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 19", + "suggested_name": "corpus_operation19" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "1a2dcadd88dba27b1cbacacdb6223a11e633ee4436205fe0d36285f7e6645300" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "2c321fa76e556169b068c5fdbdc6576da95f061fbcf8c8dc9a4128ec2664e5f3", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 19", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 19", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p19", + "target": "$.request.cookies.p19" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p19": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation19", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/19", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 19", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 19" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/19", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/19", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/19", + "method": "HEAD", + "operation_id": "corpusOperation19", + "output_fields": 0, + "path": "/items/19", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 19", + "suggested_name": "corpus_operation19" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 19", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-20", + "file": "representative-20.json", + "sha256": "e8f285c6b4a0b6e50c5dddb9b661f253d6433d0d87ee64677a69dbce7ce55e69", + "canonical_digest": "369f23fa8b4f1f7180f53f462f4137ada9f3065782d4affda7b6314b512734f3", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/20", + "operation_id": "corpusOperation20", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 20", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 20", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p20", + "target": "$.request.query.p20" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p20": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation20", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/20", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 20", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 20" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/20", + "method": "OPTIONS", + "operation_id": "corpusOperation20", + "output_fields": 1, + "path": "/items/20", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 20", + "suggested_name": "corpus_operation20" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "0d8a8374dbbfe81d9ddbc514ec9723f4e66ee304524b0aed31bcd1217e302682" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "625aafb27628a9901227c6d56911bf6eafe18b8fa82d1137ef67272b420c95d5", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 20", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 20", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p20", + "target": "$.request.query.p20" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p20": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation20", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/20", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 20", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 20" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/20", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/20", + "method": "OPTIONS", + "operation_id": "corpusOperation20", + "output_fields": 1, + "path": "/items/20", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 20", + "suggested_name": "corpus_operation20" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 20", + "version": "2.0" + } + } + } + }, + { + "id": "rep-21", + "file": "representative-21.json", + "sha256": "acfa0c990794d8767f7636101680fcdb3ab6f0f2b3d3298964b8c76b6f02e8c0", + "canonical_digest": "9b1796863b8c39a5eac8a7463675dd02f2acabe00ee81b063aa4fd4963263886", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/{p21}", + "operation_id": "corpusOperation21", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 21", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 21", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p21", + "target": "$.request.path.p21" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p21": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation21", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/{p21}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 21", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 21" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/{p21}", + "method": "GET", + "operation_id": "corpusOperation21", + "output_fields": 1, + "path": "/items/{p21}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 21", + "suggested_name": "corpus_operation21" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "6958720bdd39a877be5a8d399533b1bfab6ea191f4e3f26e187c3ba62f146ebf" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "24d9da484cfa2e2370a2d119564e289c5038dcb0f0536c98e1aad44ca7b82f27", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 21", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 21", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p21", + "target": "$.request.path.p21" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p21": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation21", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/{p21}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 21", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 21" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/{p21}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/{p21}", + "method": "GET", + "operation_id": "corpusOperation21", + "output_fields": 1, + "path": "/items/{p21}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 21", + "suggested_name": "corpus_operation21" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 21", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-22", + "file": "representative-22.json", + "sha256": "f7524fe669b795a8a294a8ec066233ee33aafa42480466e356995ad39fb7e844", + "canonical_digest": "95a86bf62de2b35e3ff093ef3589e7d0e9bef1814072f84d4676bea18ab4687f", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/22", + "operation_id": "corpusOperation22", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 22", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 22", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p22", + "target": "$.request.headers.p22" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p22": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation22", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/22", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 22", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 22" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/22", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/22", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/22", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/22", + "method": "POST", + "operation_id": "corpusOperation22", + "output_fields": 1, + "path": "/items/22", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 22", + "suggested_name": "corpus_operation22" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "18a26335be93086e4a74fcac6e8e1dc9430ea5d7bc06b20a7903281944a8ec27" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "cea999bcec66e9448170e5c6c2f5de1964307d2c6d759c9920ff8aee2919c50d", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 22", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 22", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p22", + "target": "$.request.headers.p22" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p22": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation22", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/22", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 22", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 22" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/22", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/22", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/22", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/22", + "method": "POST", + "operation_id": "corpusOperation22", + "output_fields": 1, + "path": "/items/22", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 22", + "suggested_name": "corpus_operation22" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 22", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-23", + "file": "representative-23.json", + "sha256": "906c974b0ebc5e271dbc0f84860c58f6177ba1aec9f70fee34607f8c374facf7", + "canonical_digest": "5b2900541809a626b66279eb826f546d33a3875a05eb784f872ca9d0ba89f394", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/23", + "operation_id": "corpusOperation23", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 23", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 23", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p23", + "target": "$.request.headers.p23" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p23": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation23", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/23", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 23", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 23" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/23", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/23", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/23", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/23", + "method": "PUT", + "operation_id": "corpusOperation23", + "output_fields": 1, + "path": "/items/23", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 23", + "suggested_name": "corpus_operation23" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "df2b0b63eac5950ab0861a6a8878d57d6f5054959559cef533e7c335790f3a46" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "3440f8b83dace0271d32474757e55a9955649bb79a3382542157089ee217e60c", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 23", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 23", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p23", + "target": "$.request.headers.p23" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p23": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation23", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/23", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 23", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 23" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/23", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/23", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/23", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/23", + "method": "PUT", + "operation_id": "corpusOperation23", + "output_fields": 1, + "path": "/items/23", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 23", + "suggested_name": "corpus_operation23" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 23", + "version": "2.0" + } + } + } + }, + { + "id": "rep-24", + "file": "representative-24.json", + "sha256": "f1896301ec6d2a7bdefedbde03b12e11eab8c2c52892f1f6e6208de5f5dde40c", + "canonical_digest": "20faf7e5ff709ac571212eb0d54f6ae9dcad8f4693187202a6ee59b97d25c894", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/24", + "operation_id": "corpusOperation24", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 24", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 24", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p24", + "target": "$.request.query.p24" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p24": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation24", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/24", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 24", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 24" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/24", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/24", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/24", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/24", + "method": "PATCH", + "operation_id": "corpusOperation24", + "output_fields": 1, + "path": "/items/24", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 24", + "suggested_name": "corpus_operation24" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "65ee0a168653b0dbf54743cad77da4f54c9fa6728d9a1238e8723ae0a9c2bc46" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "86056b12cb45d441017d3d3575eed16e03fe5b16ebdc92b74c24bc5ab3f7a503", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 24", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 24", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p24", + "target": "$.request.query.p24" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p24": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation24", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/24", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 24", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 24" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/24", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/24", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/24", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/24", + "method": "PATCH", + "operation_id": "corpusOperation24", + "output_fields": 1, + "path": "/items/24", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 24", + "suggested_name": "corpus_operation24" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 24", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-25", + "file": "representative-25.json", + "sha256": "2a15bdd4e4aad1a9038e292daac366f9c3dbfd53d54988774bed474365893b21", + "canonical_digest": "95975636e300fdd54fd8e298bfd842be17dda051cd69f644cbac68d0e3556892", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/{p25}", + "operation_id": "corpusOperation25", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 25", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 25", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p25", + "target": "$.request.path.p25" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p25": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation25", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/{p25}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 25", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 25" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/{p25}", + "method": "DELETE", + "operation_id": "corpusOperation25", + "output_fields": 1, + "path": "/items/{p25}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 25", + "suggested_name": "corpus_operation25" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "c965d4dce4dad170b2a93bde2534a54eebd0ed9d2ac5ab2696aa9585f4794a74" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "17887c73d178ce009a9da0af29a4aadfb1e4dd6f6ef96b4f41df2a941cec5e4d", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 25", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 25", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p25", + "target": "$.request.path.p25" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p25": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation25", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/{p25}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 25", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 25" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/{p25}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/{p25}", + "method": "DELETE", + "operation_id": "corpusOperation25", + "output_fields": 1, + "path": "/items/{p25}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 25", + "suggested_name": "corpus_operation25" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 25", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-26", + "file": "representative-26.json", + "sha256": "6abe1a26901ea129842921dfaa4f5de96fa8bb8f76e24f6240e8f0a87fd9b198", + "canonical_digest": "bcdad59cb79703c34e19b93fff6d0a88e5f567483ff922b9a19892ccb6428cc7", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/26", + "operation_id": "corpusOperation26", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 26", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 26", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p26", + "target": "$.request.headers.p26" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p26": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation26", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/26", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 26", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 26" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/26", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/26", + "method": "HEAD", + "operation_id": "corpusOperation26", + "output_fields": 0, + "path": "/items/26", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 26", + "suggested_name": "corpus_operation26" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "0489bed5c29e4a2342bf0fb98818cc509b38f7f3425c1270f75816e9821cff70" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "fcb0c48dbea568412ea865a854572e5b306474e2ff1115fc2455d125135343c5", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 26", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 26", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p26", + "target": "$.request.headers.p26" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p26": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation26", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/26", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 26", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 26" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/26", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/26", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/26", + "method": "HEAD", + "operation_id": "corpusOperation26", + "output_fields": 0, + "path": "/items/26", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 26", + "suggested_name": "corpus_operation26" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 26", + "version": "2.0" + } + } + } + }, + { + "id": "rep-27", + "file": "representative-27.json", + "sha256": "ee9520f1b77a97c26f20575030ccbc5f012dad7de3ad677da5acbfff1117ae11", + "canonical_digest": "ae30324ee31dac383ef6881aeb48d377ff642ce2898dc1626cdf60645a1ae22e", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/27", + "operation_id": "corpusOperation27", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 27", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 27", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p27", + "target": "$.request.cookies.p27" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p27": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation27", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/27", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 27", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 27" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/27", + "method": "OPTIONS", + "operation_id": "corpusOperation27", + "output_fields": 1, + "path": "/items/27", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 27", + "suggested_name": "corpus_operation27" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "6c3270dafaceae5b55a2f911e7b1aaa2e6dc706c4489645965d1da93a4de07dc" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "db34a8368d69bf43aa4b6b7a76c273cf18c11182c193dbb7b8db7359f5872b92", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 27", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 27", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p27", + "target": "$.request.cookies.p27" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p27": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation27", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/27", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 27", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 27" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/27", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/27", + "method": "OPTIONS", + "operation_id": "corpusOperation27", + "output_fields": 1, + "path": "/items/27", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 27", + "suggested_name": "corpus_operation27" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 27", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-28", + "file": "representative-28.json", + "sha256": "9949eca03f9f5d603f51536ef8882eec1c48d3f51c1ea4d4651b130766589443", + "canonical_digest": "8b9cb181cc7e6ca0576511d2771fb747c0ec49bdaa77041d50275b9f6a8ac4d1", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/28", + "operation_id": "corpusOperation28", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 28", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 28", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p28", + "target": "$.request.query.p28" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p28": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation28", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/28", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 28", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 28" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/28", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/28", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/28", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/28", + "method": "GET", + "operation_id": "corpusOperation28", + "output_fields": 1, + "path": "/items/28", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 28", + "suggested_name": "corpus_operation28" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "c528641e585e4f5630f3a5704d091812a2a18971caa37242282eb3f16da4c67a" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "d3adb23d7a667a9af5d811f23629a70be015dc23092f285a37a24ca81a304d13", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 28", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 28", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p28", + "target": "$.request.query.p28" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p28": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation28", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/28", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 28", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 28" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/28", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/28", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/28", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/28", + "method": "GET", + "operation_id": "corpusOperation28", + "output_fields": 1, + "path": "/items/28", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 28", + "suggested_name": "corpus_operation28" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 28", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-29", + "file": "representative-29.json", + "sha256": "80339041ae250b644679606648cf6d38a618c0d62138aee044bb5c91aa761e7d", + "canonical_digest": "107816923a913e89784a25319ecc05059729095fc01c5076f01600fc6a5f075a", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/{p29}", + "operation_id": "corpusOperation29", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 29", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 29", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p29", + "target": "$.request.path.p29" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p29": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation29", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/{p29}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 29", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 29" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "POST /items/{p29}", + "method": "POST", + "operation_id": "corpusOperation29", + "output_fields": 1, + "path": "/items/{p29}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 29", + "suggested_name": "corpus_operation29" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "a74a24b3424c5f9e523891395908353043bd9596c817a05e35ae02b83fa20d41" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "09bb975376a094ccaf4c56d959ebd503bbbdf2ffa826cce6191b088c94204741", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 29", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 29", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p29", + "target": "$.request.path.p29" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p29": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation29", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/{p29}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 29", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 29" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/{p29}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "POST /items/{p29}", + "method": "POST", + "operation_id": "corpusOperation29", + "output_fields": 1, + "path": "/items/{p29}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 29", + "suggested_name": "corpus_operation29" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 29", + "version": "2.0" + } + } + } + }, + { + "id": "rep-30", + "file": "representative-30.json", + "sha256": "2c82a403311cce4c8c4241c68a45d469dbefc4527aada4e384ebc72fdb641359", + "canonical_digest": "f589dd931b7e659ed2b5716309fa956e82d30f13c139e8c013f6c7bc690655ae", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/30", + "operation_id": "corpusOperation30", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 30", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 30", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p30", + "target": "$.request.headers.p30" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p30": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation30", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/30", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 30", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 30" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/30", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/30", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/30", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/30", + "method": "PUT", + "operation_id": "corpusOperation30", + "output_fields": 1, + "path": "/items/30", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 30", + "suggested_name": "corpus_operation30" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "bdda992f77480c88566611002815e365c56c86f2f4140d731fc842b5e445fcb4" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "b210c43409a8ec7c22c0b18f4fbb0cfc5bf883114bd9f4eeba0a0fb17aeda36e", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 30", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 30", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p30", + "target": "$.request.headers.p30" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p30": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation30", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/30", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 30", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 30" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/30", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/30", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/30", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/30", + "method": "PUT", + "operation_id": "corpusOperation30", + "output_fields": 1, + "path": "/items/30", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 30", + "suggested_name": "corpus_operation30" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 30", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-31", + "file": "representative-31.json", + "sha256": "2884e3e566aa6cfb0130534b361dbe33c95bc06fbef748b19956da9bfbfdf8d0", + "canonical_digest": "800ae791e9308ccd6115f90a69fe15d3441deccdee50c32b4d0ba12b519d6640", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/31", + "operation_id": "corpusOperation31", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 31", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 31", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p31", + "target": "$.request.cookies.p31" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p31": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation31", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/31", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 31", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 31" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/31", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/31", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/31", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/31", + "method": "PATCH", + "operation_id": "corpusOperation31", + "output_fields": 1, + "path": "/items/31", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 31", + "suggested_name": "corpus_operation31" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "bb5a48106f54194d8477be02e7f502b804781267c8918321582238824c216387" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "4a5f4ea802f160c99bb81ef391fad9f7d73f7a7ec6a35860ca3bca61d96ac153", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 31", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 31", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p31", + "target": "$.request.cookies.p31" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p31": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation31", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/31", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 31", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 31" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/31", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/31", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/31", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/31", + "method": "PATCH", + "operation_id": "corpusOperation31", + "output_fields": 1, + "path": "/items/31", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 31", + "suggested_name": "corpus_operation31" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 31", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-32", + "file": "representative-32.json", + "sha256": "4954da505785f5c63b26387ef199db5eb7e497215ab8499dd3f24720a73cc8e5", + "canonical_digest": "0ef86109a68a36b3ae6a67cbd7f9c1df92bdc3f6f6840248ae0a4713340ea981", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/32", + "operation_id": "corpusOperation32", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 32", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 32", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p32", + "target": "$.request.query.p32" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p32": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation32", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/32", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 32", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 32" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/32", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/32", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/32", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/32", + "method": "DELETE", + "operation_id": "corpusOperation32", + "output_fields": 1, + "path": "/items/32", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 32", + "suggested_name": "corpus_operation32" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "ff3ef935a42e4860c953a7426783eb30e990b201f581b377b7efcd59e2d98e7d" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "1d3050a3ed6aa76e4fa0c36f2624f6ada83fc302953b606f6f60a76d63c7ec54", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 32", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 32", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p32", + "target": "$.request.query.p32" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p32": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation32", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/32", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 32", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 32" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/32", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/32", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/32", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/32", + "method": "DELETE", + "operation_id": "corpusOperation32", + "output_fields": 1, + "path": "/items/32", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 32", + "suggested_name": "corpus_operation32" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 32", + "version": "2.0" + } + } + } + }, + { + "id": "rep-33", + "file": "representative-33.json", + "sha256": "ff8c48b74ba9e3bbbe24140928411c07965d1486da4f12061a448e616bd92d5c", + "canonical_digest": "7217032f264ff4aec219d513f0adf7b7ad71a0192ef0f7dea6f793700a41b752", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/{p33}", + "operation_id": "corpusOperation33", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 33", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 33", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p33", + "target": "$.request.path.p33" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p33": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation33", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/{p33}", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 33", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 33" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/{p33}", + "method": "HEAD", + "operation_id": "corpusOperation33", + "output_fields": 0, + "path": "/items/{p33}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 33", + "suggested_name": "corpus_operation33" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "1c31ab36cbad661ea96a114ec0728b4754163f962c7b01bef77771cef46e4927" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "f01480c764a3922951cdc437c4e9425413d34796f96eedb94d01d9707e922c13", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 33", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 33", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p33", + "target": "$.request.path.p33" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p33": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation33", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/{p33}", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 33", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 33" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/{p33}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/{p33}", + "method": "HEAD", + "operation_id": "corpusOperation33", + "output_fields": 0, + "path": "/items/{p33}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 33", + "suggested_name": "corpus_operation33" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 33", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-34", + "file": "representative-34.json", + "sha256": "e386caf8964036b2e8b564d9deb026b809c264910cb6e1aa3ada993de19ac891", + "canonical_digest": "9e340330f24b88f38f54c126b2fe683617076009cb08858b40f09bd29e135421", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/34", + "operation_id": "corpusOperation34", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 34", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 34", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p34", + "target": "$.request.headers.p34" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p34": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation34", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/34", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 34", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 34" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/34", + "method": "OPTIONS", + "operation_id": "corpusOperation34", + "output_fields": 1, + "path": "/items/34", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 34", + "suggested_name": "corpus_operation34" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "4f54f1279047b5a447b71c6c9ce099000c9af45e4f2ca3e151e635e4bdcf24dc" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "69db31657eebcb3a63e0f3b8cdc0ea78ac2c7abdc578e30b21e74bbc76e6b8f5", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 34", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 34", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p34", + "target": "$.request.headers.p34" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p34": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation34", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/34", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 34", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 34" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/34", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/34", + "method": "OPTIONS", + "operation_id": "corpusOperation34", + "output_fields": 1, + "path": "/items/34", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 34", + "suggested_name": "corpus_operation34" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 34", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-35", + "file": "representative-35.json", + "sha256": "77b4f388d7095d8bb8cd17d4d355e371fd2674388cae8f1b7095d408db6ac539", + "canonical_digest": "28e1f54e1a032932cad8d8dad18482f3c54e76b519138db294f16e32bd4a02ed", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/35", + "operation_id": "corpusOperation35", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 35", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 35", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p35", + "target": "$.request.headers.p35" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p35": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation35", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/35", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 35", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 35" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/35", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/35", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/35", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/35", + "method": "GET", + "operation_id": "corpusOperation35", + "output_fields": 1, + "path": "/items/35", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 35", + "suggested_name": "corpus_operation35" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "8a587830d6aaa8f1a6545c134aa7da676af8911cd25608eaf92e1b12cef7553a" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "0a0f9531c9f9746d93b517139ccd15ef6c27d7c2d6291cf1442a13efb00bbc58", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 35", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 35", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p35", + "target": "$.request.headers.p35" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p35": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation35", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/35", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 35", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 35" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/35", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/35", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/35", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/35", + "method": "GET", + "operation_id": "corpusOperation35", + "output_fields": 1, + "path": "/items/35", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 35", + "suggested_name": "corpus_operation35" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 35", + "version": "2.0" + } + } + } + }, + { + "id": "rep-36", + "file": "representative-36.json", + "sha256": "1510b01b4470fbf98bc5b9b0132d2a9066a2f2a3601f6fb265c1365d2d957ee0", + "canonical_digest": "7da2a19e53f5ba2a1bba354f5689a37c97f2747423d210ab46faadfc3257d19c", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/36", + "operation_id": "corpusOperation36", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 36", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 36", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p36", + "target": "$.request.query.p36" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p36": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation36", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/36", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 36", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 36" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/36", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/36", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/36", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/36", + "method": "POST", + "operation_id": "corpusOperation36", + "output_fields": 1, + "path": "/items/36", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 36", + "suggested_name": "corpus_operation36" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "88c4e3f6fefc2ac6ceb82fdd43abcb7ff79a06e6fed736d782a31ee38a6a0faa" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "1bdaa0245b65a270e2f867694622d0d74745f39f66d2a05c744ccf7e7be6c3f8", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 36", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 36", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p36", + "target": "$.request.query.p36" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p36": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation36", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/36", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 36", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 36" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/36", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/36", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/36", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/36", + "method": "POST", + "operation_id": "corpusOperation36", + "output_fields": 1, + "path": "/items/36", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 36", + "suggested_name": "corpus_operation36" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 36", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-37", + "file": "representative-37.json", + "sha256": "7f27d6a6c2bca84003046cc4395d007ec5be0fd8622c23d20d47a89563de1ac1", + "canonical_digest": "b7cba36014f0c3947453cd0c54662a16f65a9e5bcd9dba084b8b6c0d26746044", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/{p37}", + "operation_id": "corpusOperation37", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 37", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 37", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p37", + "target": "$.request.path.p37" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p37": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation37", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/{p37}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 37", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 37" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/{p37}", + "method": "PUT", + "operation_id": "corpusOperation37", + "output_fields": 1, + "path": "/items/{p37}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 37", + "suggested_name": "corpus_operation37" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "8bf33bc3a06c02f561642bbfba5b0e86bb014a96751cc52969c1bb00f04183c9" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "5f0eafaa7ac0b07a5e463a8e0fea25690e34f2ac00d4516cac9bbdb7ad368312", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 37", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 37", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p37", + "target": "$.request.path.p37" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p37": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation37", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/{p37}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 37", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 37" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/{p37}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PUT /items/{p37}", + "method": "PUT", + "operation_id": "corpusOperation37", + "output_fields": 1, + "path": "/items/{p37}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 37", + "suggested_name": "corpus_operation37" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 37", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-38", + "file": "representative-38.json", + "sha256": "dfd009a76b885c9ea5ccf1921dc346445c04be898b27ea0a7de6fff7de760bc0", + "canonical_digest": "868111ff9a499a6b86641b51b68dc4ecb1e97b9b331ab7ef256940f8660f18c9", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/38", + "operation_id": "corpusOperation38", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 38", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 38", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p38", + "target": "$.request.headers.p38" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p38": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation38", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/38", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 38", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 38" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/38", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/38", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/38", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PATCH /items/38", + "method": "PATCH", + "operation_id": "corpusOperation38", + "output_fields": 1, + "path": "/items/38", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 38", + "suggested_name": "corpus_operation38" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "b1649cd1aa0e12ed9d623bb2c3353bd29a06daeb9d4c075b5d83975bbaaccf34" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "3dfccec8c5b6325c3b353567f1817fc7684b573cf41f330e9127e5bce4193cec", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 38", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 38", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p38", + "target": "$.request.headers.p38" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p38": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation38", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/38", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 38", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 38" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/38", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/38", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/38", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PATCH /items/38", + "method": "PATCH", + "operation_id": "corpusOperation38", + "output_fields": 1, + "path": "/items/38", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 38", + "suggested_name": "corpus_operation38" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 38", + "version": "2.0" + } + } + } + }, + { + "id": "rep-39", + "file": "representative-39.json", + "sha256": "5958032799fd1f4f45fce184ed40c75bf570c14028eb8f7d11498bcb7b065878", + "canonical_digest": "892de65450f650a6213749b28ef1285d65e30ea795c73e69f2f0411222279f6c", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/39", + "operation_id": "corpusOperation39", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 39", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 39", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p39", + "target": "$.request.cookies.p39" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p39": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation39", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/39", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 39", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 39" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/39", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/39", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/39", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/39", + "method": "DELETE", + "operation_id": "corpusOperation39", + "output_fields": 1, + "path": "/items/39", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 39", + "suggested_name": "corpus_operation39" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "e5ac58943ddf4d0cc84a236e9d6fde19afb322648ffe923a6bea3fe9fd97a06e" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "8b48ad70a2d60b0eff4659cbcfc63e3d1fbd7b8a9a0171a7d8b2b9f33363596a", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 39", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 39", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p39", + "target": "$.request.cookies.p39" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p39": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation39", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/39", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 39", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 39" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/39", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/39", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/39", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/39", + "method": "DELETE", + "operation_id": "corpusOperation39", + "output_fields": 1, + "path": "/items/39", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 39", + "suggested_name": "corpus_operation39" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 39", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-40", + "file": "representative-40.json", + "sha256": "d14a5e5d3567a8ca9c18266b42f7b254488e5820b0f7b01c1800b960011dbcdc", + "canonical_digest": "a0cd9b0e278ca496440c0a1da05edc5273d5d866721f99f574f45cf03af9bb5c", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/40", + "operation_id": "corpusOperation40", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 40", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 40", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p40", + "target": "$.request.query.p40" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p40": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation40", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/40", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 40", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 40" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/40", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/40", + "method": "HEAD", + "operation_id": "corpusOperation40", + "output_fields": 0, + "path": "/items/40", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 40", + "suggested_name": "corpus_operation40" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "15e33407ec019f8d44d6c3bbfbda67a5948b006663d5d3a713bfa6c0a5b846a0" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "305bde53db0152f2569d0bacd83e18dfd50c268e8f8a8a993a0e86a17de1ad2b", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 40", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 40", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p40", + "target": "$.request.query.p40" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p40": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation40", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/40", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 40", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 40" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/40", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/40", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/40", + "method": "HEAD", + "operation_id": "corpusOperation40", + "output_fields": 0, + "path": "/items/40", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 40", + "suggested_name": "corpus_operation40" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 40", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-41", + "file": "representative-41.json", + "sha256": "b2bcd396bb24c4b0f4cc24dae5c91ddcee158232f6b7104953712d3145530502", + "canonical_digest": "7ee5b1e2d9c260094e9df2472e6dafa88c89c9ddc61e9244b4f9879a8b9a5996", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/{p41}", + "operation_id": "corpusOperation41", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 41", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 41", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p41", + "target": "$.request.path.p41" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p41": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation41", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/{p41}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 41", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 41" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/{p41}", + "method": "OPTIONS", + "operation_id": "corpusOperation41", + "output_fields": 1, + "path": "/items/{p41}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 41", + "suggested_name": "corpus_operation41" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "b8edb69ee0103e45c29174033b741c40f0a36758f91657279f917694044f4478" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "e527f5b56f345b31f6e06beb129f79b4d5d997ec38dd0193360106373241944d", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 41", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 41", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p41", + "target": "$.request.path.p41" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p41": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation41", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/{p41}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 41", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 41" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/{p41}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/{p41}", + "method": "OPTIONS", + "operation_id": "corpusOperation41", + "output_fields": 1, + "path": "/items/{p41}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 41", + "suggested_name": "corpus_operation41" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 41", + "version": "2.0" + } + } + } + }, + { + "id": "rep-42", + "file": "representative-42.json", + "sha256": "c0edaf4bb1d59e6f7d57a1049e0dab90b4a9d91b80bb0d0ee29158fad40fcf16", + "canonical_digest": "c24174b2ad9c521c6a6aa68bff2f821e4b923f6f0bdef87973f0fb57016a6d57", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/42", + "operation_id": "corpusOperation42", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 42", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 42", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p42", + "target": "$.request.headers.p42" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p42": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation42", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/42", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 42", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 42" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/42", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/42", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/42", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/42", + "method": "GET", + "operation_id": "corpusOperation42", + "output_fields": 1, + "path": "/items/42", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 42", + "suggested_name": "corpus_operation42" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "088fa592fb2fadecde5c80a7929564b7fe07f977cc1489ba11faef17d737a250" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "c8bd86851b9b5f86b0e8f9c8cdadb2070917f86332368dc54dbe778c845e120a", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 42", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 42", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p42", + "target": "$.request.headers.p42" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p42": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation42", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/42", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 42", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 42" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/42", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/42", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/42", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/42", + "method": "GET", + "operation_id": "corpusOperation42", + "output_fields": 1, + "path": "/items/42", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 42", + "suggested_name": "corpus_operation42" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 42", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-43", + "file": "representative-43.json", + "sha256": "344059b33f831de8d8f859618bbba1b27dbd962185f83df29820729417d7789a", + "canonical_digest": "3821ceba0fa62cc6a42ef99131c57035ee7985406261505277c6cd94a2b7cfb4", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "POST", + "path": "/items/43", + "operation_id": "corpusOperation43", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 43", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 43", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p43", + "target": "$.request.cookies.p43" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p43": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation43", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/43", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 43", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 43" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/43", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/43", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/43", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/43", + "method": "POST", + "operation_id": "corpusOperation43", + "output_fields": 1, + "path": "/items/43", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 43", + "suggested_name": "corpus_operation43" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "fff9f2f539e9044fa1ea5d1a77f6979b97e9013b2a71026b7ad1c8811b501563" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "d44b8c3644f74050b6132e10c81bae01fbb9c5cee368e0ef358591299a249ead", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 43", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 43", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p43", + "target": "$.request.cookies.p43" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p43": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation43", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "POST", + "path_template": "/items/43", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 43", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 43" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "POST /items/43", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "POST /items/43", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "POST /items/43", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "POST /items/43", + "method": "POST", + "operation_id": "corpusOperation43", + "output_fields": 1, + "path": "/items/43", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 43", + "suggested_name": "corpus_operation43" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 43", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-44", + "file": "representative-44.json", + "sha256": "b317a43fa89e2431447d7059a1567f25e9c0a6eecad7076806447299cce6c15d", + "canonical_digest": "b7e8e18dc1aecd1f27aa8e6e0fc346912fb3d1062cf253920164dcb246f5d2ca", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PUT", + "path": "/items/44", + "operation_id": "corpusOperation44", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 44", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 44", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p44", + "target": "$.request.query.p44" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p44": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation44", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/44", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 44", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 44" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/44", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/44", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/44", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/44", + "method": "PUT", + "operation_id": "corpusOperation44", + "output_fields": 1, + "path": "/items/44", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 44", + "suggested_name": "corpus_operation44" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "b59e60ac3579cd88daf718920878ec1293e1d59d3aa9ed75c2de01e3f8074ff8" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "74544bedddfe51d1df3ea632e689986ff9e0249b0b3c6132a88ede3c56285fa7", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 44", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 44", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p44", + "target": "$.request.query.p44" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p44": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation44", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PUT", + "path_template": "/items/44", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 44", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 44" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PUT /items/44", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PUT /items/44", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PUT /items/44", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "PUT /items/44", + "method": "PUT", + "operation_id": "corpusOperation44", + "output_fields": 1, + "path": "/items/44", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 44", + "suggested_name": "corpus_operation44" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 44", + "version": "2.0" + } + } + } + }, + { + "id": "rep-45", + "file": "representative-45.json", + "sha256": "df903f2fb729e3e7c3c577fe4f62845ff4a3a983d62b86f7bad28953c86febfd", + "canonical_digest": "5cf55018af288f9df4cbba10dcf2d1bd55137ca9a208f58b4c3a04877fee7568", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "PATCH", + "path": "/items/{p45}", + "operation_id": "corpusOperation45", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 45", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 45", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p45", + "target": "$.request.path.p45" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p45": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation45", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/{p45}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 45", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 45" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/{p45}", + "method": "PATCH", + "operation_id": "corpusOperation45", + "output_fields": 1, + "path": "/items/{p45}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 45", + "suggested_name": "corpus_operation45" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "65d6ae2e5bb1fc4cd59b5e39887b1b07098cb7cae43dcb316fe4196e3be88fea" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "bb4e8bf0d0be34be887c03b21fee3356a46b2aee43049acbebf51368d5fbbc13", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 45", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 45", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p45", + "target": "$.request.path.p45" + }, + { + "required": true, + "source": "$.mcp.body", + "target": "$.request.body" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "body": { + "description": "Тело запроса (application/json)", + "fields": { + "name": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "p45": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation45", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "PATCH", + "path_template": "/items/{p45}", + "request_contract": { + "body_field": "body", + "body_required": true, + "variants": [ + { + "media_type": "application/json", + "schema_variant": 0 + } + ], + "version": "1" + }, + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 45", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 45" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "PATCH /items/{p45}", + "severity": "warning" + } + ], + "input_fields": 2, + "key": "PATCH /items/{p45}", + "method": "PATCH", + "operation_id": "corpusOperation45", + "output_fields": 1, + "path": "/items/{p45}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 45", + "suggested_name": "corpus_operation45" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 45", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-46", + "file": "representative-46.json", + "sha256": "bd257bca997125e9b59864c80f7417ef97723fcee72591ed183d633405959a9e", + "canonical_digest": "410269ecb03265d89c29547e1d6e42b0673275db116ed8c9ac4c96f69b2f051a", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "DELETE", + "path": "/items/46", + "operation_id": "corpusOperation46", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 46", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 46", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p46", + "target": "$.request.headers.p46" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p46": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation46", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/46", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 46", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 46" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/46", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/46", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/46", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/46", + "method": "DELETE", + "operation_id": "corpusOperation46", + "output_fields": 1, + "path": "/items/46", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 46", + "suggested_name": "corpus_operation46" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "c6ca23d3fd84146ec1a9ac2e55abcb216085dbf2a880b4356eb05cc058ba6ed4" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "829c70f4fe337392061fee3009dbe235a19fe063b57f6c88f2c1b7aed8413be1", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 46", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 46", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p46", + "target": "$.request.headers.p46" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p46": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation46", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "DELETE", + "path_template": "/items/46", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 202 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 46", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 46" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "DELETE /items/46", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "DELETE /items/46", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "DELETE /items/46", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "DELETE /items/46", + "method": "DELETE", + "operation_id": "corpusOperation46", + "output_fields": 1, + "path": "/items/46", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 46", + "suggested_name": "corpus_operation46" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 46", + "version": "3.1.0" + } + } + } + }, + { + "id": "rep-47", + "file": "representative-47.json", + "sha256": "c0534a712bc1656553e242688433e09c0969b8daf9c620f9282600f1fccbc47d", + "canonical_digest": "a07081e8892a089dc8909b36fd691701bdcfb58561db163eb208fab8ce495624", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "Swagger 2.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "HEAD", + "path": "/items/47", + "operation_id": "corpusOperation47", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 47", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 47", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p47", + "target": "$.request.headers.p47" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p47": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation47", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/47", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 47", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 47" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/47", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/47", + "method": "HEAD", + "operation_id": "corpusOperation47", + "output_fields": 0, + "path": "/items/47", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 47", + "suggested_name": "corpus_operation47" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "e8dfae85504a7fc342ab0c86a3bed2e60e783b85f6d5f4d84b48fb7b6ccb8b47" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description", + "missing_response_schema", + "empty_output_schema" + ], + "canonical_preview_digest": "001b1abf3fc6829704588a861ac5d4f51663c5781220ee36bb2647a082b40e54", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 47", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 47", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p47", + "target": "$.request.headers.p47" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p47": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation47", + "output_mapping": { + "rules": [ + { + "required": true, + "source": "$.response.body", + "target": "$.output" + } + ] + }, + "output_schema": { + "description": "Успешный ответ без тела", + "nullable": false, + "required": true, + "type": "null" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "HEAD", + "path_template": "/items/47", + "response_contract": [ + { + "schema_variant": 0, + "status_code": 204 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 47", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 47" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "missing_response_schema", + "message": "У метода не найдена схема успешного ответа, результат будет описан как общий объект.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "empty_output_schema", + "message": "В ответе не найдено отдельных полей. Перед публикацией проверьте схему ответа и маппинг результата.", + "operation_key": "HEAD /items/47", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "HEAD /items/47", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "HEAD /items/47", + "method": "HEAD", + "operation_id": "corpusOperation47", + "output_fields": 0, + "path": "/items/47", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 47", + "suggested_name": "corpus_operation47" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "swagger", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 47", + "version": "2.0" + } + } + } + }, + { + "id": "rep-48", + "file": "representative-48.json", + "sha256": "900c2c23f50671a0c69254938829396a44fc1139743aec5ea7032d06de3e611b", + "canonical_digest": "343b7374576c4792b83e0c28b1d925376a93f8bd44a4ba4b0fb313fbcf46f68a", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "OPTIONS", + "path": "/items/48", + "operation_id": "corpusOperation48", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 48", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 48", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p48", + "target": "$.request.query.p48" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p48": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation48", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/48", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 48", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 48" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/48", + "method": "OPTIONS", + "operation_id": "corpusOperation48", + "output_fields": 1, + "path": "/items/48", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 48", + "suggested_name": "corpus_operation48" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "8a20820455e4be26069ce5241ea43711c7f4e7365d88be485ba280b5dd9fc72c" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "5b1c2d40ea513010bc2fecde834c881afd6ce783374cca5a04162444f4c1ab47", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 48", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 48", + "input_mapping": { + "rules": [ + { + "required": false, + "source": "$.mcp.p48", + "target": "$.request.query.p48" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p48": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation48", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "OPTIONS", + "path_template": "/items/48", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 200 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 48", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 48" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "OPTIONS /items/48", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "OPTIONS /items/48", + "method": "OPTIONS", + "operation_id": "corpusOperation48", + "output_fields": 1, + "path": "/items/48", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 48", + "suggested_name": "corpus_operation48" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 48", + "version": "3.0.3" + } + } + } + }, + { + "id": "rep-49", + "file": "representative-49.json", + "sha256": "137b9555072bcf5c8652926fae0e0eff224d01a1d2416f3071c8e3d5fef49f16", + "canonical_digest": "b84c37ab3958d37ab21e7a750d7525760aaac0a1be425cf8dfa2e2e0133fa8fa", + "origin": "synthetic: Story 2.14 deterministic corpus generator", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "representative", + "expected_preview": { + "operation_count": 1, + "operations": [ + { + "method": "GET", + "path": "/items/{p49}", + "operation_id": "corpusOperation49", + "candidate": { + "category": "corpus", + "description": "Synthetic operation 49", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 49", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p49", + "target": "$.request.path.p49" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p49": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation49", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/{p49}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 49", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 49" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/{p49}", + "method": "GET", + "operation_id": "corpusOperation49", + "output_fields": 1, + "path": "/items/{p49}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 49", + "suggested_name": "corpus_operation49" + }, + "actionable": true, + "blocker_codes": [], + "candidate_digest": "86e4df8c54da258c60b63799a0d4abc36327147abdd33ace73fca1cb90cd585b" + } + ], + "finding_codes": [ + "missing_description", + "parameter_descriptions_missing", + "weak_tool_description" + ], + "canonical_preview_digest": "02adff9a3309768b70d17788ebe16f7a13ef442b1b6483f4c45047d1d7305e8f", + "canonical_preview": { + "findings": [], + "groups": [ + { + "key": "corpus", + "operations": [ + { + "category": "corpus", + "description": "Synthetic operation 49", + "draft": { + "category": "corpus", + "display_name": "Synthetic operation 49", + "input_mapping": { + "rules": [ + { + "required": true, + "source": "$.mcp.p49", + "target": "$.request.path.p49" + } + ] + }, + "input_schema": { + "description": "Входные параметры MCP-инструмента", + "fields": { + "p49": { + "nullable": false, + "required": true, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "name": "corpus_operation49", + "output_mapping": { + "rules": [ + { + "required": false, + "source": "$.response.body.id", + "target": "$.output.id" + } + ] + }, + "output_schema": { + "description": "Ответ API", + "fields": { + "id": { + "nullable": false, + "required": false, + "type": "string" + } + }, + "nullable": false, + "required": true, + "type": "object" + }, + "target": { + "base_url": "https://api.example.test/v1", + "method": "GET", + "path_template": "/items/{p49}", + "response_contract": [ + { + "media_type": "application/json", + "schema_variant": 0, + "status_code": 201 + } + ] + }, + "tool_description": { + "description": "Synthetic operation 49", + "examples": [ + { + "input": {} + } + ], + "tags": [ + "corpus" + ], + "title": "Synthetic operation 49" + }, + "wizard_state": {} + }, + "findings": [ + { + "code": "missing_description", + "message": "У метода нет description. Перед публикацией лучше описать, когда агенту стоит вызывать этот инструмент.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + }, + { + "code": "parameter_descriptions_missing", + "message": "У 1 входных параметров нет описания. Модели будет сложнее понять, какие значения туда передавать.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + }, + { + "code": "weak_tool_description", + "message": "Описание инструмента слишком короткое или техническое. Перед публикацией добавьте, когда агент должен вызывать инструмент и что будет в успешном ответе.", + "operation_key": "GET /items/{p49}", + "severity": "warning" + } + ], + "input_fields": 1, + "key": "GET /items/{p49}", + "method": "GET", + "operation_id": "corpusOperation49", + "output_fields": 1, + "path": "/items/{p49}", + "server_urls": [ + "https://api.example.test/v1" + ], + "suggested_display_name": "Synthetic operation 49", + "suggested_name": "corpus_operation49" + } + ], + "title": "corpus" + } + ], + "source": { + "format": "openapi", + "servers": [ + "https://api.example.test/v1" + ], + "title": "Synthetic corpus 49", + "version": "3.1.0" + } + } + } + }, + { + "id": "hostile-00", + "file": "hostile-empty.json", + "sha256": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "canonical_digest": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "unsupported_document", + "operation_count": 0 + } + }, + { + "id": "hostile-01", + "file": "hostile-malformed.json", + "sha256": "a9d15d823d7991d6a03ea7d8f3164917801394e565a13ce4c703c4e9cebae97e", + "canonical_digest": null, + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "invalid_document", + "operation_count": 0 + } + }, + { + "id": "hostile-02", + "file": "hostile-trace.json", + "sha256": "93c38cbc25c13bf6bf214cb3e5bec7f58bb6f8130c9b683d5e8aa944bdf399cc", + "canonical_digest": "d0f1a5461674d9247e7cd17edddc1759107e7bd2c3fb275f21d98a35f1d4b7d4", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "unsupported_http_method", + "operation_count": 0 + } + }, + { + "id": "hostile-03", + "file": "hostile-xml.json", + "sha256": "91c8c8596b4f3e457b3bb0ef2a7ca7f4444ee1bbaaa6266d5b3ef57a40998dd1", + "canonical_digest": "b57c0402a3a0af3ca2a564fdfe2a5aab480b6eb391b77505283ccdc84804a0ae", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "unsupported_media_type", + "operation_count": 0 + } + }, + { + "id": "hostile-04", + "file": "hostile-secret.json", + "sha256": "21742b0719fa4130bea7c52a2e805ad2b97cd12b8ca7ce716c33d01caf8d0d34", + "canonical_digest": "2265d8405b5f7b8cc699fe4c7bc7424c76b5888e92420e2b983dd8bb90020341", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "secret_like_example", + "operation_count": 0 + } + }, + { + "id": "hostile-05", + "file": "hostile-oversized.json", + "sha256": "99e2643db10661f1a23ddc14e9f05cb8b615dfec0c470de6f69c0aa073f4a4fc", + "canonical_digest": "25dda3bfdff11690d47dd35c13286a92679a83139f1554eaa56b978b31f653d8", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "limit_exceeded", + "operation_count": 0 + } + }, + { + "id": "hostile-06", + "file": "hostile-deep.json", + "sha256": "2a8d551e95929c31f8a66a40021467a42ce95245766d173eefc751f4b87963f5", + "canonical_digest": "fbbb9b8f33072e4cc407621455788d71fc2e2335f5cad7201efd0c7d1c13e354", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "limit_exceeded", + "operation_count": 0 + } + }, + { + "id": "hostile-07", + "file": "hostile-aliases.yaml", + "sha256": "eb1c1c07236b70550ad487d32470c7791928930d9e62a047be2d1c858c917eae", + "canonical_digest": null, + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "limit_exceeded", + "operation_count": 0 + } + }, + { + "id": "hostile-08", + "file": "hostile-cycle.json", + "sha256": "6398f8694b9bdd9ca8d262520339eb080a7cfbaf7424a6da1767bb3c39e64d99", + "canonical_digest": "a27a1d13b10680f27f7d73714da1278eadf263afab629eba3c69191b32c1d155", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "parse_error": null, + "operation_count": 1, + "warning_findings": [ + { + "code": "missing_servers", + "severity": "Warning", + "operation_key": null + } + ], + "blocker_findings": [], + "unresolved_references": [], + "recursive_edge": { + "source": "/components/schemas/Node/properties/next/$ref", + "target": "/components/schemas/Node" + }, + "mapped_recursive_pointer": "/components/schemas/Node/properties/next/properties/next", + "response_schema": "object_with_next_property" + } + }, + { + "id": "hostile-09", + "file": "hostile-external-ref.json", + "sha256": "19415da83546af15f12fbcf006a0c0a751a75a4d3442ab75b368ced31eb800bb", + "canonical_digest": "acfd7aab72d67bee3c48bb4b45886ef70d16661bfceb36e368f93169a0715ab7", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "external_reference_not_fetched", + "operation_count": 0 + } + }, + { + "id": "hostile-10", + "file": "hostile-duplicate-ids.json", + "sha256": "ad11729cb05dd86dedf73e4ff7b823161efbbf79f9f9451fd55e96669577a6aa", + "canonical_digest": "9aae7f895869f3a6e7b186ea507e96439dabf0bec15dd52e4f635c376e1e3d45", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "error_or_finding": "duplicate_operation_id", + "operation_count": 0 + } + }, + { + "id": "hostile-11", + "file": "hostile-composition-conflict.json", + "sha256": "d4a1120da066f6e3ba22c131e306a277f6a2dc6d1286f38c951bb8574e330c1f", + "canonical_digest": "a187c94230e068ae97d1bddc5bc6c65af3e6cca9109e8964cac4a5d68bc4bdd2", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.1.0", + "classification": "hostile", + "expected_preview": { + "parse_error": null, + "operation_count": 1, + "warning_findings": [ + { + "code": "missing_servers", + "severity": "Warning", + "operation_key": null + } + ], + "blocker_findings": [ + { + "code": "all_of_conflict", + "severity": "Error", + "operation_key": "GET /hostile", + "location": "/paths/~1hostile/get/responses/200/content/application~1json/schema/allOf" + } + ], + "composition": { + "operator": "allOf", + "branch_count": 2 + }, + "response_schema": "allOf_conflict_branches_preserved" + } + }, + { + "id": "hostile-12", + "file": "hostile-security-scope.json", + "sha256": "ff745a5c8c613790e64672162973ea0d2e77f2b70ae715841cf397ee4951da1e", + "canonical_digest": "f2f9627d754ed9f77cf41d910de84f525c00bd3a0f9f2ed511a9c388b1813db9", + "origin": "synthetic: Story 2.14 hostile input", + "license": "CC0-1.0 synthetic; no third-party content", + "specification_version": "OpenAPI 3.0.3", + "classification": "hostile", + "expected_preview": { + "parse_error": null, + "operation_keys": [ + "GET /public", + "GET /secure" + ], + "warning_findings": [], + "blocker_findings": [ + { + "code": "unsupported_security_requirement", + "severity": "Error", + "operation_key": "GET /secure", + "location": "/security/0" + } + ] + } + } + ], + "compatibility_impact": "Corpus 1.0.3 adds hostile-security-scope.json: an effective-security-scope fixture showing that a document-level requirement blocks only the inherited candidate (GET /secure, location /security/0) while the public candidate with an explicit security: [] stays actionable and no document-global blocker is produced; all 50 representative previews and the previous hostile oracles are unchanged." +} diff --git a/crates/crank-import/tests/corpus/matrix.rs b/crates/crank-import/tests/corpus/matrix.rs new file mode 100644 index 0000000..754c9da --- /dev/null +++ b/crates/crank-import/tests/corpus/matrix.rs @@ -0,0 +1,822 @@ +//! Executable normalizer probes for every normative support-matrix row. +use super::*; +use crank_import::rest::{NormalizedSchemaKind, normalize_verified_bundle}; + +fn assert_actionable(ir: &crank_import::rest::NormalizedIr, context: &str) { + let preview = preview_from_ir(ir); + assert!( + !preview.findings.iter().any(|finding| { + finding.severity == crank_import::rest::ImportFindingSeverity::Error + }), + "{context} has a document blocker: {:?}", + preview.findings + ); + assert!( + preview + .groups + .iter() + .flat_map(|group| &group.operations) + .all(|candidate| { + !candidate.findings.iter().any(|finding| { + finding.severity == crank_import::rest::ImportFindingSeverity::Error + }) + }), + "{context} unexpectedly blocked: {:?}", + preview.groups + ); +} + +#[test] +fn ac_1_support_matrix_rows_have_exact_construct_contracts() { + let matrix_text = fs::read_to_string(tests_root().join("support-matrix.yaml")) + .expect("support matrix exists"); + let matrix: serde_yaml::Value = serde_yaml::from_str(&matrix_text).expect("valid YAML"); + assert_eq!(matrix["matrix_version"].as_str(), Some("1.0.2")); + assert!( + matrix["compatibility_impact"] + .as_str() + .is_some_and(|s| !s.trim().is_empty()) + ); + let rows = matrix["constructs"].as_sequence().expect("construct rows"); + assert!(rows.len() >= 375); + let mut construct_keys = std::collections::BTreeSet::new(); + for row in rows { + assert!( + row["specification_version"].as_str().is_some_and(|s| [ + "OpenAPI 3.0", + "OpenAPI 3.1", + "Swagger 2.0" + ] + .contains(&s)) + ); + assert!(row["construct_id"].as_str().is_some_and(|s| !s.is_empty())); + assert!(matches!( + row["status"].as_str(), + Some("supported" | "unsupported") + )); + assert!( + row["preserved_semantics"] + .as_str() + .is_some_and(|s| !s.trim().is_empty()) + ); + assert!( + row["expected_finding"] + .as_str() + .is_some_and(|s| !s.trim().is_empty()) + ); + let key = format!( + "{}:{}", + row["specification_version"].as_str().unwrap(), + row["construct_id"].as_str().unwrap() + ); + assert!( + construct_keys.insert(key.clone()), + "duplicate normative construct row: {key}" + ); + if row["status"] == "supported" { + assert_eq!( + row["expected_finding"], "none", + "supported construct has a finding: {key}" + ); + } else { + assert_ne!( + row["expected_finding"], "none", + "unsupported construct has no finding: {key}" + ); + } + } + for version in ["OpenAPI 3.0", "OpenAPI 3.1", "Swagger 2.0"] { + // Exhaustive accounting: every normative row of this format must be + // matched by an executed probe before the loop completes. + let mut unprobed = rows + .iter() + .filter(|row| row["specification_version"] == version) + .map(|row| { + ( + version.to_owned(), + row["construct_id"].as_str().unwrap().to_owned(), + ) + }) + .collect::>(); + let mut probed = |construct: &str| { + let taken = unprobed.remove(&(version.to_owned(), construct.to_owned())); + assert!(taken, "{version} double-probes or misses {construct}"); + }; + let ids = rows + .iter() + .filter(|r| r["specification_version"] == version) + .filter_map(|r| r["construct_id"].as_str()) + .collect::>(); + for id in [ + "http.method.get", + "http.method.post", + "http.method.put", + "http.method.patch", + "http.method.delete", + "http.method.head", + "http.method.options", + "parameter.location.path", + "parameter.location.query", + "parameter.location.header", + "parameter.location.cookie", + "request_body.application/json", + "request_body.application/x-www-form-urlencoded", + "request_body.multipart/form-data", + "reference.local", + "reference.external_allowlisted", + "composition.allOf", + "composition.oneOf", + "composition.anyOf", + "security.bearer", + "security.basic", + "security.api_key", + "media_type.application_xml.request", + "media_type.application_xml.response", + "http.method.trace", + "http.method.connect", + ] { + assert!(ids.contains(&id), "{version} matrix misses {id}"); + } + for security_kind in ["bearer", "basic", "api_key"] { + let construct = format!("security.{security_kind}"); + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let probe = if version == "Swagger 2.0" { + json!({ + "swagger":"2.0", "info":{"title":"Security probe","version":"1"}, + "securityDefinitions":{"probe": if security_kind == "bearer" { + json!({"type":"oauth2","flow":"implicit","authorizationUrl":"https://auth.example.test","scopes":{}}) + } else if security_kind == "api_key" { + json!({"type":"apiKey","name":"X-Key","in":"header"}) + } else { + json!({"type":"basic"}) + }}, + "paths":{"/probe":{"get":{"security":[{"probe":[]}],"operationId":"securityProbe","responses":{"200":{"description":"ok"}}}}} + }) + } else { + let scheme = match security_kind { + "bearer" => json!({"type":"http","scheme":"bearer"}), + "basic" => json!({"type":"http","scheme":"basic"}), + "api_key" => json!({"type":"apiKey","name":"X-Key","in":"header"}), + _ => unreachable!(), + }; + json!({ + "openapi": if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Security probe","version":"1"}, + "servers":[{"url":"https://matrix.example.test"}], + "components":{"securitySchemes":{"probe":scheme}}, + "paths":{"/probe":{"get":{"security":[{"probe":[]}],"operationId":"securityProbe","responses":{"200":{"description":"ok"}}}}} + }) + }; + assert_eq!( + row["status"], "unsupported", + "security is not yet persisted as Auth Profile semantics" + ); + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + let expected_finding = row["expected_finding"].as_str().unwrap(); + let requirement = ir + .findings + .iter() + .find(|finding| { + finding.code == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error + }) + .unwrap_or_else(|| { + panic!( + "{version} {construct} must be explicitly blocked: {:?}", + ir.findings + ) + }); + assert_eq!( + requirement.operation_key.as_deref(), + Some("GET /probe"), + "{version} {construct} blocker must belong to the affected candidate" + ); + assert_eq!( + requirement.location.pointer, "/paths/~1probe/get/security/0", + "{version} {construct} blocker must point at the local requirement" + ); + let preview = preview_from_ir(&ir); + let candidate = &preview.groups[0].operations[0]; + assert!( + candidate + .findings + .iter() + .any(|finding| finding.code == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error), + "{version} {construct} candidate must be blocked: {:?}", + candidate.findings + ); + assert!( + ir.coverage.iter().any(|entry| entry.location.pointer + == "/paths/~1probe/get/security/0" + && entry.disposition == CoverageDisposition::Finding), + "{version} {construct} has no finding coverage" + ); + probed(&construct); + } + { + let construct = "security.override_empty"; + let override_probe = |path: &str| { + if version == "Swagger 2.0" { + json!({ + "swagger":"2.0", "info":{"title":"Security override probe","version":"1"}, + "securityDefinitions":{"probe":{"type":"basic"}}, + "security":[{"probe":[]}], + "paths":{path:{"get":{"security":[],"operationId":"securityOverride","responses":{"200":{"description":"ok"}}}}} + }) + } else { + json!({ + "openapi": if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Security override probe","version":"1"}, + "servers":[{"url":"https://matrix.example.test"}], + "components":{"securitySchemes":{"probe":{"type":"http","scheme":"basic"}}}, + "security":[{"probe":[]}], + "paths":{path:{"get":{"security":[],"operationId":"securityOverride","responses":{"200":{"description":"ok"}}}}} + }) + } + }; + let source = serde_json::to_string(&override_probe("/override")).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + assert!( + ir.findings + .iter() + .all(|finding| finding.code != "unsupported_security_requirement"), + "explicit empty security override must disable inheritance: {:?}", + ir.findings + ); + let preview = preview_from_ir(&ir); + let candidate = &preview.groups[0].operations[0]; + assert!( + candidate + .findings + .iter() + .all(|finding| finding.severity + != crank_import::rest::ImportFindingSeverity::Error), + "overridden operation must remain actionable: {:?}", + candidate.findings + ); + probed(construct); + } + { + let construct = "security.mixed_operations"; + let mixed_probe = if version == "Swagger 2.0" { + json!({ + "swagger":"2.0", "info":{"title":"Mixed security probe","version":"1"}, + "securityDefinitions":{"probe":{"type":"basic"}}, + "security":[{"probe":[]}], + "paths":{ + "/public":{"get":{"security":[],"operationId":"publicProbe","responses":{"200":{"description":"ok"}}}}, + "/secured":{"get":{"operationId":"securedProbe","responses":{"200":{"description":"ok"}}}} + } + }) + } else { + json!({ + "openapi": if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Mixed security probe","version":"1"}, + "servers":[{"url":"https://matrix.example.test"}], + "components":{"securitySchemes":{"probe":{"type":"http","scheme":"basic"}}}, + "security":[{"probe":[]}], + "paths":{ + "/public":{"get":{"security":[],"operationId":"publicProbe","responses":{"200":{"description":"ok"}}}}, + "/secured":{"get":{"operationId":"securedProbe","responses":{"200":{"description":"ok"}}}} + } + }) + }; + let source = serde_json::to_string(&mixed_probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + let expected_finding = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap()["expected_finding"] + .as_str() + .unwrap(); + let requirements = ir + .findings + .iter() + .filter(|finding| finding.code == expected_finding) + .collect::>(); + assert_eq!( + requirements.len(), + 1, + "exactly the inherited operation must be blocked: {:?}", + requirements + ); + assert_eq!( + requirements[0].operation_key.as_deref(), + Some("GET /secured"), + "blocker must belong only to the affected candidate" + ); + assert_eq!(requirements[0].location.pointer, "/security/0"); + let preview = preview_from_ir(&ir); + let mut by_key = std::collections::BTreeMap::new(); + for group in &preview.groups { + for candidate in &group.operations { + by_key.insert(candidate.key.clone(), candidate); + } + } + let public = by_key.get("GET /public").expect("public candidate present"); + assert!( + public + .findings + .iter() + .all(|finding| finding.severity + != crank_import::rest::ImportFindingSeverity::Error), + "public operation must stay actionable: {:?}", + public.findings + ); + let secured = by_key + .get("GET /secured") + .expect("secured candidate present"); + assert!( + secured + .findings + .iter() + .any(|finding| finding.code == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error), + "secured operation must be blocked: {:?}", + secured.findings + ); + assert!( + ir.coverage + .iter() + .any(|entry| entry.location.pointer == "/security/0" + && entry.disposition == CoverageDisposition::Finding), + "mixed probe has no finding coverage" + ); + probed(construct); + } + for method in [ + "get", "post", "put", "patch", "delete", "head", "options", "trace", "connect", + ] { + let construct = format!("http.method.{method}"); + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let mut path_item = serde_json::Map::new(); + path_item.insert( + method.to_owned(), + json!({ + "operationId":"methodProbe", "responses":{"200":{"description":"ok"}} + }), + ); + let probe = if version == "Swagger 2.0" { + json!({"swagger":"2.0","info":{"title":"Method probe","version":"1"},"paths":{"/probe":path_item,"/normal":{"get":{"operationId":"normalProbe","responses":{"200":{"description":"ok"}}}}}}) + } else { + json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Method probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{"/probe":path_item,"/normal":{"get":{"operationId":"normalProbe","responses":{"200":{"description":"ok"}}}}}}) + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + if row["status"] == "supported" { + assert!( + ir.operations + .iter() + .any( + |operation| serde_json::to_value(operation.method).unwrap().as_str() + == Some(&method.to_ascii_uppercase()) + ), + "{version} {construct} was not preserved" + ); + assert_eq!(row["expected_finding"], "none"); + assert_actionable(&ir, &format!("{version} {construct}")); + } else { + let expected_finding = row["expected_finding"].as_str().unwrap(); + assert!( + ir.operations + .iter() + .any(|operation| operation.path == "/normal"), + "{version} {construct} must not discard a supported neighbour" + ); + assert!( + ir.findings + .iter() + .any(|finding| finding.code == expected_finding + && finding.severity + == crank_import::rest::ImportFindingSeverity::Error), + "{version} {construct} missing exact finding {expected_finding}: {:?}", + ir.findings + ); + assert!( + ir.coverage + .iter() + .any(|entry| entry.construct_id.ends_with(&format!("/{method}")) + && entry.disposition == CoverageDisposition::Finding), + "{version} {construct} has no finding coverage" + ); + } + probed(&construct); + } + for location in ["path", "query", "header", "cookie"] { + let construct = format!("parameter.location.{location}"); + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let parameter = if version == "Swagger 2.0" { + json!({"name":"probe","in":location,"required":location == "path","type":"string"}) + } else { + json!({"name":"probe","in":location,"required":location == "path","schema":{"type":"string"}}) + }; + let path = if location == "path" { + "/probe/{probe}" + } else { + "/probe" + }; + let operation = json!({"operationId":"parameterProbe","parameters":[parameter],"responses":{"200":{"description":"ok"}}}); + let probe = if version == "Swagger 2.0" { + json!({"swagger":"2.0","info":{"title":"Parameter probe","version":"1"},"paths":{path:{"get":operation}}}) + } else { + json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Parameter probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{path:{"get":operation}}}) + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + if row["status"] == "supported" { + let parameter = ir.operations[0] + .parameters + .iter() + .find(|parameter| parameter.name == "probe") + .unwrap(); + assert_eq!( + serde_json::to_value(parameter.location).unwrap(), + location, + "{version} {construct} location was changed" + ); + assert!( + parameter.schema.is_some(), + "{version} {construct} schema was lost" + ); + assert_eq!(parameter.required, location == "path"); + let preview = preview_from_ir(&ir); + let candidate = &preview.groups[0].operations[0]; + let expected_root = match location { + "path" => "$.request.path.", + "query" => "$.request.query.", + "header" => "$.request.headers.", + "cookie" => "$.request.cookies.", + _ => unreachable!(), + }; + assert!( + candidate + .draft + .input_mapping + .rules + .iter() + .any(|rule| rule.source == "$.mcp.probe" + && rule.target.starts_with(expected_root)), + "{version} {construct} input mapping missing {expected_root}: {:?}", + candidate.draft.input_mapping + ); + assert_actionable(&ir, &format!("{version} {construct}")); + } else { + let expected_finding = row["expected_finding"].as_str().unwrap(); + assert!( + ir.operations[0].findings.iter().any(|finding| finding.code + == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error + && finding.location.pointer == "/paths/~1probe/get/parameters/0"), + "{version} {construct} missing exact finding {expected_finding}" + ); + } + probed(&construct); + } + for media_type in [ + "application/json", + "application/x-www-form-urlencoded", + "multipart/form-data", + ] { + let construct = format!("request_body.{media_type}"); + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let operation = if version == "Swagger 2.0" { + let mut operation = + json!({"operationId":"bodyProbe","responses":{"200":{"description":"ok"}}}); + operation["consumes"] = json!([media_type]); + if media_type == "application/json" { + operation["parameters"] = json!([{"name":"body","in":"body","required":true,"schema":{"type":"object","properties":{"value":{"type":"string"}}}}]); + } else { + operation["parameters"] = + json!([{"name":"value","in":"formData","required":true,"type":"string"}]); + } + operation + } else { + json!({"operationId":"bodyProbe","requestBody":{"required":true,"content":{ + (media_type):{"schema":{"type":"object","properties":{"value":{"type":"string"}}}} + }},"responses":{"200":{"description":"ok"}}}) + }; + let probe = if version == "Swagger 2.0" { + json!({"swagger":"2.0","info":{"title":"Body probe","version":"1"},"paths":{"/probe":{"post":operation}}}) + } else { + json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Body probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{"/probe":{"post":operation}}}) + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + if row["status"] == "supported" { + let variant = ir.operations[0] + .request_body_variants + .iter() + .find(|variant| variant.content_type == media_type) + .expect("request body variant retained"); + assert!( + variant.schema.is_some(), + "{version} {construct} schema was lost: {:?}", + variant + ); + assert!( + variant.required, + "{version} {construct} required request body contract was lost: {variant:?}" + ); + let preview = preview_from_ir(&ir); + let contract = preview.groups[0].operations[0] + .draft + .target + .request_contract + .as_ref() + .expect("draft request contract"); + assert!(contract.body_required); + assert!( + contract + .variants + .iter() + .any(|variant| variant.media_type == media_type) + ); + assert_actionable(&ir, &format!("{version} {construct}")); + } else { + let expected_finding = row["expected_finding"].as_str().unwrap(); + assert!( + ir.operations[0].findings.iter().any(|finding| finding.code + == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error) + ); + } + probed(&construct); + } + for (construct, is_request) in [ + ("media_type.application_xml.request", true), + ("media_type.application_xml.response", false), + ] { + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let operation = if version == "Swagger 2.0" { + let mut operation = json!({"operationId":"xmlProbe","responses":{"200":{"description":"ok","schema":{"type":"string"}}}}); + if is_request { + operation["consumes"] = json!(["application/xml"]); + operation["parameters"] = json!([{"name":"body","in":"body","required":true,"schema":{"type":"string"}}]); + } else { + operation["produces"] = json!(["application/xml"]); + } + operation + } else if is_request { + json!({"operationId":"xmlProbe","requestBody":{"content":{"application/xml":{"schema":{"type":"string"}}}},"responses":{"200":{"description":"ok"}}}) + } else { + json!({"operationId":"xmlProbe","responses":{"200":{"description":"ok","content":{"application/xml":{"schema":{"type":"string"}}}}}}) + }; + let probe = if version == "Swagger 2.0" { + json!({"swagger":"2.0","info":{"title":"XML probe","version":"1"},"paths":{"/probe":{"post":operation}}}) + } else { + json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"XML probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{"/probe":{"post":operation}}}) + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + let expected_finding = row["expected_finding"].as_str().unwrap(); + assert_eq!(row["status"], "unsupported"); + let expected_pointer = if version == "Swagger 2.0" { + if is_request { + "/paths/~1probe/post/consumes/0" + } else { + "/paths/~1probe/post/produces/0" + } + } else if is_request { + "/paths/~1probe/post/requestBody/content/application~1xml" + } else { + "/paths/~1probe/post/responses/200/content/application~1xml" + }; + assert!( + ir.operations[0] + .findings + .iter() + .any(|finding| finding.code == expected_finding + && finding.severity == crank_import::rest::ImportFindingSeverity::Error + && finding.location.pointer == expected_pointer), + "{version} {construct} missing exact blocker {expected_finding}: {:?}", + ir.operations[0].findings + ); + probed(construct); + } + for composition in ["allOf", "oneOf", "anyOf"] { + let construct = format!("composition.{composition}"); + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let schema = json!({(composition):[{"type":"object","properties":{"id":{"type":"string"}}},{"type":"object","properties":{"name":{"type":"string"}}}]}); + let response = if version == "Swagger 2.0" { + json!({"description":"ok","schema":schema}) + } else { + json!({"description":"ok","content":{"application/json":{"schema":schema}}}) + }; + let probe = if version == "Swagger 2.0" { + json!({"swagger":"2.0","info":{"title":"Composition probe","version":"1"},"paths":{"/probe":{"get":{"operationId":"compositionProbe","responses":{"200":response}}}}}) + } else { + json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Composition probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{"/probe":{"get":{"operationId":"compositionProbe","responses":{"200":response}}}}}) + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = normalize(&source).unwrap(); + validate_normalized_ir(&ir).unwrap(); + assert_eq!(row["status"], "supported"); + assert!(ir.operations[0].response_variants[0].schema.as_ref().is_some_and(|schema| + if composition == "allOf" { + matches!(&schema.kind, NormalizedSchemaKind::Object { properties, .. } + if properties.contains_key("id") && properties.contains_key("name")) + } else { + matches!(&schema.kind, NormalizedSchemaKind::Composition { operator, variants } + if operator == composition && variants.len() == 2 + && matches!(&variants[0].kind, NormalizedSchemaKind::Object { properties, .. } + if properties.contains_key("id")) + && matches!(&variants[1].kind, NormalizedSchemaKind::Object { properties, .. } + if properties.contains_key("name"))) + }), + "{version} {construct} composition was not retained: {:?}", ir.operations[0].response_variants); + assert_eq!(row["expected_finding"], "none"); + assert_actionable(&ir, &format!("{version} {construct}")); + probed(&construct); + } + for external in [false, true] { + let construct = if external { + "reference.external_allowlisted" + } else { + "reference.local" + }; + let row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap(); + let reference = if external { + "https://schemas.example.test/root.yaml#/Item" + } else if version == "Swagger 2.0" { + "#/definitions/Item" + } else { + "#/components/schemas/Item" + }; + let schema = json!({"$ref":reference}); + let response = if version == "Swagger 2.0" { + json!({"description":"ok","schema":schema}) + } else { + json!({"description":"ok","content":{"application/json":{"schema":schema}}}) + }; + let probe = if version == "Swagger 2.0" { + let mut root = json!({"swagger":"2.0","info":{"title":"Reference probe","version":"1"},"paths":{"/probe":{"get":{"operationId":"referenceProbe","responses":{"200":response}}}}}); + if !external { + root["definitions"] = + json!({"Item":{"type":"object","properties":{"id":{"type":"string"}}}}); + } + root + } else { + let mut root = json!({"openapi":if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Reference probe","version":"1"},"servers":[{"url":"https://matrix.example.test"}],"paths":{"/probe":{"get":{"operationId":"referenceProbe","responses":{"200":response}}}}}); + if !external { + root["components"] = json!({"schemas":{"Item":{"type":"object","properties":{"id":{"type":"string"}}}}}); + } + root + }; + let source = serde_json::to_string(&probe).unwrap(); + let ir = if external { + let external_source = + "Item: { type: object, properties: { id: { type: string } } }"; + let snapshot = crank_import::rest::ExternalDocumentSnapshot { + canonical_uri: "https://schemas.example.test/root.yaml".to_owned(), + digest: SourceDigest::parse(hex(external_source.as_bytes())).unwrap(), + document: external_source.to_owned(), + }; + let digest = SourceDigest::parse(hex(source.as_bytes())).unwrap(); + normalize_verified_bundle( + &source, + digest, + &[snapshot], + &NormalizationConfig::default(), + ) + .unwrap() + } else { + normalize(&source).unwrap() + }; + validate_normalized_ir(&ir).unwrap(); + assert_eq!(row["status"], "supported"); + assert!( + !ir.reference_graph.edges.is_empty(), + "{version} {construct} did not resolve through a source-backed edge" + ); + assert!( + ir.unresolved_references.is_empty(), + "{version} {construct} remains unresolved" + ); + assert!( + matches!( + ir.operations[0].response_variants[0].schema.as_ref().map(|schema| &schema.kind), + Some(NormalizedSchemaKind::Object { properties, .. }) if properties.contains_key("id") + ), + "{version} {construct} resolved schema was not projected into the operation" + ); + assert_actionable(&ir, &format!("{version} {construct}")); + assert_eq!(row["expected_finding"], "none"); + probed(construct); + } + for code in 200..300 { + let construct = format!("response.{code}"); + let response_row = rows + .iter() + .find(|row| { + row["specification_version"] == version && row["construct_id"] == construct + }) + .unwrap_or_else(|| panic!("{version} matrix misses {construct}")); + assert!( + ids.contains(&construct.as_str()), + "{version} matrix misses {construct}" + ); + assert_eq!(response_row["status"], "supported"); + assert_eq!(response_row["expected_finding"], "none"); + let has_body = !matches!(code, 204 | 205); + let source = if version == "Swagger 2.0" { + json!({ + "swagger":"2.0", "info":{"title":"Matrix probe","version":"1"}, + "paths":{"/probe":{"get":{"operationId":"matrixProbe","responses":{ + code.to_string(): if has_body {json!({"description":"success","schema":{"type":"object","properties":{"id":{"type":"string"}}}})} else {json!({"description":"success"})} + }}}} + }) + } else { + json!({ + "openapi": if version == "OpenAPI 3.0" {"3.0.3"} else {"3.1.0"}, + "info":{"title":"Matrix probe","version":"1"}, + "servers":[{"url":"https://matrix.example.test"}], + "paths":{"/probe":{"get":{"operationId":"matrixProbe","responses":{ + code.to_string(): if has_body {json!({"description":"success","content":{"application/json":{"schema":{"type":"object","properties":{"id":{"type":"string"}}}}}})} else {json!({"description":"success"})} + }}}} + }) + }; + let source = serde_json::to_string(&source).unwrap(); + let ir = normalize(&source) + .unwrap_or_else(|error| panic!("{version} {construct} probe rejected: {error}")); + validate_normalized_ir(&ir).unwrap_or_else(|error| { + panic!("{version} {construct} probe has invalid ledger: {error}") + }); + let response = ir.operations[0] + .response_variants + .iter() + .find(|variant| variant.status_code == code) + .unwrap_or_else(|| panic!("{version} {construct} was not preserved")); + assert_eq!( + response.schema.is_some(), + has_body, + "{version} {construct} body contract differs from 204/205 bodyless response semantics" + ); + assert!( + !ir.operations[0] + .findings + .iter() + .any(|finding| finding.severity + == crank_import::rest::ImportFindingSeverity::Error), + "{version} {construct} unexpectedly blocked: {:?}", + ir.operations[0].findings + ); + probed(&construct); + } + assert!( + unprobed.is_empty(), + "normative {version} rows lack an executed probe: {unprobed:?}" + ); + } +} diff --git a/crates/crank-import/tests/corpus/representative-00.json b/crates/crank-import/tests/corpus/representative-00.json new file mode 100644 index 0000000..c2054cc --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-00.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 00", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/0": { + "get": { + "operationId": "corpusOperation00", + "parameters": [ + { + "in": "query", + "name": "p00", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 00", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-01.json b/crates/crank-import/tests/corpus/representative-01.json new file mode 100644 index 0000000..4455caa --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-01.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 01", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/{p01}": { + "post": { + "operationId": "corpusOperation01", + "parameters": [ + { + "in": "path", + "name": "p01", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 01", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-02.json b/crates/crank-import/tests/corpus/representative-02.json new file mode 100644 index 0000000..5a920e1 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-02.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 02", + "version": "1.0" + }, + "paths": { + "/items/2": { + "put": { + "operationId": "corpusOperation02", + "parameters": [ + { + "in": "header", + "name": "p02", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "202": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 02", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-03.json b/crates/crank-import/tests/corpus/representative-03.json new file mode 100644 index 0000000..2c24ece --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-03.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 03", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/3": { + "patch": { + "operationId": "corpusOperation03", + "parameters": [ + { + "in": "cookie", + "name": "p03", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 03", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-04.json b/crates/crank-import/tests/corpus/representative-04.json new file mode 100644 index 0000000..6a26ba2 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-04.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 04", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/4": { + "delete": { + "operationId": "corpusOperation04", + "parameters": [ + { + "in": "query", + "name": "p04", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 04", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-05.json b/crates/crank-import/tests/corpus/representative-05.json new file mode 100644 index 0000000..f73fbdd --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-05.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 05", + "version": "1.0" + }, + "paths": { + "/items/{p05}": { + "head": { + "operationId": "corpusOperation05", + "parameters": [ + { + "in": "path", + "name": "p05", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 05", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-06.json b/crates/crank-import/tests/corpus/representative-06.json new file mode 100644 index 0000000..5feecad --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-06.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 06", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/6": { + "options": { + "operationId": "corpusOperation06", + "parameters": [ + { + "in": "header", + "name": "p06", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 06", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-07.json b/crates/crank-import/tests/corpus/representative-07.json new file mode 100644 index 0000000..910c286 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-07.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 07", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/7": { + "get": { + "operationId": "corpusOperation07", + "parameters": [ + { + "in": "cookie", + "name": "p07", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 07", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-08.json b/crates/crank-import/tests/corpus/representative-08.json new file mode 100644 index 0000000..e2a82e6 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-08.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 08", + "version": "1.0" + }, + "paths": { + "/items/8": { + "post": { + "operationId": "corpusOperation08", + "parameters": [ + { + "in": "query", + "name": "p08", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 08", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-09.json b/crates/crank-import/tests/corpus/representative-09.json new file mode 100644 index 0000000..1367954 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-09.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 09", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/{p09}": { + "put": { + "operationId": "corpusOperation09", + "parameters": [ + { + "in": "path", + "name": "p09", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 09", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-10.json b/crates/crank-import/tests/corpus/representative-10.json new file mode 100644 index 0000000..b71a9b9 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-10.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 10", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/10": { + "patch": { + "operationId": "corpusOperation10", + "parameters": [ + { + "in": "header", + "name": "p10", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 10", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-11.json b/crates/crank-import/tests/corpus/representative-11.json new file mode 100644 index 0000000..1f03774 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-11.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 11", + "version": "1.0" + }, + "paths": { + "/items/11": { + "delete": { + "operationId": "corpusOperation11", + "parameters": [ + { + "in": "header", + "name": "p11", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 11", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-12.json b/crates/crank-import/tests/corpus/representative-12.json new file mode 100644 index 0000000..6cb78a4 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-12.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 12", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/12": { + "head": { + "operationId": "corpusOperation12", + "parameters": [ + { + "in": "query", + "name": "p12", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 12", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-13.json b/crates/crank-import/tests/corpus/representative-13.json new file mode 100644 index 0000000..92e0088 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-13.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 13", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/{p13}": { + "options": { + "operationId": "corpusOperation13", + "parameters": [ + { + "in": "path", + "name": "p13", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 13", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-14.json b/crates/crank-import/tests/corpus/representative-14.json new file mode 100644 index 0000000..e8af539 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-14.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 14", + "version": "1.0" + }, + "paths": { + "/items/14": { + "get": { + "operationId": "corpusOperation14", + "parameters": [ + { + "in": "header", + "name": "p14", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 14", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-15.json b/crates/crank-import/tests/corpus/representative-15.json new file mode 100644 index 0000000..6a30322 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-15.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 15", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/15": { + "post": { + "operationId": "corpusOperation15", + "parameters": [ + { + "in": "cookie", + "name": "p15", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 15", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-16.json b/crates/crank-import/tests/corpus/representative-16.json new file mode 100644 index 0000000..88e11b5 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-16.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 16", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/16": { + "put": { + "operationId": "corpusOperation16", + "parameters": [ + { + "in": "query", + "name": "p16", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 16", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-17.json b/crates/crank-import/tests/corpus/representative-17.json new file mode 100644 index 0000000..a69109d --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-17.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 17", + "version": "1.0" + }, + "paths": { + "/items/{p17}": { + "patch": { + "operationId": "corpusOperation17", + "parameters": [ + { + "in": "path", + "name": "p17", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 17", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-18.json b/crates/crank-import/tests/corpus/representative-18.json new file mode 100644 index 0000000..381fe6c --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-18.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 18", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/18": { + "delete": { + "operationId": "corpusOperation18", + "parameters": [ + { + "in": "header", + "name": "p18", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 18", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-19.json b/crates/crank-import/tests/corpus/representative-19.json new file mode 100644 index 0000000..ea8aeee --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-19.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 19", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/19": { + "head": { + "operationId": "corpusOperation19", + "parameters": [ + { + "in": "cookie", + "name": "p19", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 19", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-20.json b/crates/crank-import/tests/corpus/representative-20.json new file mode 100644 index 0000000..55761d5 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-20.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 20", + "version": "1.0" + }, + "paths": { + "/items/20": { + "options": { + "operationId": "corpusOperation20", + "parameters": [ + { + "in": "query", + "name": "p20", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 20", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-21.json b/crates/crank-import/tests/corpus/representative-21.json new file mode 100644 index 0000000..9944d43 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-21.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 21", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/{p21}": { + "get": { + "operationId": "corpusOperation21", + "parameters": [ + { + "in": "path", + "name": "p21", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 21", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-22.json b/crates/crank-import/tests/corpus/representative-22.json new file mode 100644 index 0000000..26a8ea9 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-22.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 22", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/22": { + "post": { + "operationId": "corpusOperation22", + "parameters": [ + { + "in": "header", + "name": "p22", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 22", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-23.json b/crates/crank-import/tests/corpus/representative-23.json new file mode 100644 index 0000000..af3e70a --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-23.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 23", + "version": "1.0" + }, + "paths": { + "/items/23": { + "put": { + "operationId": "corpusOperation23", + "parameters": [ + { + "in": "header", + "name": "p23", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "204": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 23", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-24.json b/crates/crank-import/tests/corpus/representative-24.json new file mode 100644 index 0000000..52266d2 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-24.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 24", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/24": { + "patch": { + "operationId": "corpusOperation24", + "parameters": [ + { + "in": "query", + "name": "p24", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 24", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-25.json b/crates/crank-import/tests/corpus/representative-25.json new file mode 100644 index 0000000..62abb1a --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-25.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 25", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/{p25}": { + "delete": { + "operationId": "corpusOperation25", + "parameters": [ + { + "in": "path", + "name": "p25", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 25", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-26.json b/crates/crank-import/tests/corpus/representative-26.json new file mode 100644 index 0000000..68cc56c --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-26.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 26", + "version": "1.0" + }, + "paths": { + "/items/26": { + "head": { + "operationId": "corpusOperation26", + "parameters": [ + { + "in": "header", + "name": "p26", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 26", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-27.json b/crates/crank-import/tests/corpus/representative-27.json new file mode 100644 index 0000000..3ce0a9c --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-27.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 27", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/27": { + "options": { + "operationId": "corpusOperation27", + "parameters": [ + { + "in": "cookie", + "name": "p27", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 27", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-28.json b/crates/crank-import/tests/corpus/representative-28.json new file mode 100644 index 0000000..bb52153 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-28.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 28", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/28": { + "get": { + "operationId": "corpusOperation28", + "parameters": [ + { + "in": "query", + "name": "p28", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 28", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-29.json b/crates/crank-import/tests/corpus/representative-29.json new file mode 100644 index 0000000..5370da0 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-29.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 29", + "version": "1.0" + }, + "paths": { + "/items/{p29}": { + "post": { + "operationId": "corpusOperation29", + "parameters": [ + { + "in": "path", + "name": "p29", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 29", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-30.json b/crates/crank-import/tests/corpus/representative-30.json new file mode 100644 index 0000000..02788f8 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-30.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 30", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/30": { + "put": { + "operationId": "corpusOperation30", + "parameters": [ + { + "in": "header", + "name": "p30", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 30", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-31.json b/crates/crank-import/tests/corpus/representative-31.json new file mode 100644 index 0000000..2c14859 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-31.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 31", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/31": { + "patch": { + "operationId": "corpusOperation31", + "parameters": [ + { + "in": "cookie", + "name": "p31", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 31", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-32.json b/crates/crank-import/tests/corpus/representative-32.json new file mode 100644 index 0000000..48555d7 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-32.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 32", + "version": "1.0" + }, + "paths": { + "/items/32": { + "delete": { + "operationId": "corpusOperation32", + "parameters": [ + { + "in": "query", + "name": "p32", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 32", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-33.json b/crates/crank-import/tests/corpus/representative-33.json new file mode 100644 index 0000000..6151829 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-33.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 33", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/{p33}": { + "head": { + "operationId": "corpusOperation33", + "parameters": [ + { + "in": "path", + "name": "p33", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 33", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-34.json b/crates/crank-import/tests/corpus/representative-34.json new file mode 100644 index 0000000..57a7ecd --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-34.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 34", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/34": { + "options": { + "operationId": "corpusOperation34", + "parameters": [ + { + "in": "header", + "name": "p34", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 34", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-35.json b/crates/crank-import/tests/corpus/representative-35.json new file mode 100644 index 0000000..ac83d90 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-35.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 35", + "version": "1.0" + }, + "paths": { + "/items/35": { + "get": { + "operationId": "corpusOperation35", + "parameters": [ + { + "in": "header", + "name": "p35", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 35", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-36.json b/crates/crank-import/tests/corpus/representative-36.json new file mode 100644 index 0000000..137d91e --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-36.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 36", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/36": { + "post": { + "operationId": "corpusOperation36", + "parameters": [ + { + "in": "query", + "name": "p36", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 36", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-37.json b/crates/crank-import/tests/corpus/representative-37.json new file mode 100644 index 0000000..bc8a388 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-37.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 37", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/{p37}": { + "put": { + "operationId": "corpusOperation37", + "parameters": [ + { + "in": "path", + "name": "p37", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 37", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-38.json b/crates/crank-import/tests/corpus/representative-38.json new file mode 100644 index 0000000..294aa36 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-38.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 38", + "version": "1.0" + }, + "paths": { + "/items/38": { + "patch": { + "operationId": "corpusOperation38", + "parameters": [ + { + "in": "header", + "name": "p38", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "202": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 38", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-39.json b/crates/crank-import/tests/corpus/representative-39.json new file mode 100644 index 0000000..1eaaaad --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-39.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 39", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/39": { + "delete": { + "operationId": "corpusOperation39", + "parameters": [ + { + "in": "cookie", + "name": "p39", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 39", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-40.json b/crates/crank-import/tests/corpus/representative-40.json new file mode 100644 index 0000000..8b59a5c --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-40.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 40", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/40": { + "head": { + "operationId": "corpusOperation40", + "parameters": [ + { + "in": "query", + "name": "p40", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 40", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-41.json b/crates/crank-import/tests/corpus/representative-41.json new file mode 100644 index 0000000..5e3a966 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-41.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 41", + "version": "1.0" + }, + "paths": { + "/items/{p41}": { + "options": { + "operationId": "corpusOperation41", + "parameters": [ + { + "in": "path", + "name": "p41", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 41", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-42.json b/crates/crank-import/tests/corpus/representative-42.json new file mode 100644 index 0000000..528a306 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-42.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 42", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/42": { + "get": { + "operationId": "corpusOperation42", + "parameters": [ + { + "in": "header", + "name": "p42", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 42", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-43.json b/crates/crank-import/tests/corpus/representative-43.json new file mode 100644 index 0000000..52c6eae --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-43.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 43", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/43": { + "post": { + "operationId": "corpusOperation43", + "parameters": [ + { + "in": "cookie", + "name": "p43", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "204": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 43", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-44.json b/crates/crank-import/tests/corpus/representative-44.json new file mode 100644 index 0000000..bf9f1c8 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-44.json @@ -0,0 +1,67 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 44", + "version": "1.0" + }, + "paths": { + "/items/44": { + "put": { + "operationId": "corpusOperation44", + "parameters": [ + { + "in": "query", + "name": "p44", + "required": false, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 44", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-45.json b/crates/crank-import/tests/corpus/representative-45.json new file mode 100644 index 0000000..399589e --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-45.json @@ -0,0 +1,65 @@ +{ + "info": { + "title": "Synthetic corpus 45", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/{p45}": { + "patch": { + "operationId": "corpusOperation45", + "parameters": [ + { + "in": "path", + "name": "p45", + "required": true, + "schema": { + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": { + "properties": { + "name": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 45", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-46.json b/crates/crank-import/tests/corpus/representative-46.json new file mode 100644 index 0000000..35cf339 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-46.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 46", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/46": { + "delete": { + "operationId": "corpusOperation46", + "parameters": [ + { + "in": "header", + "name": "p46", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "202": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 46", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-47.json b/crates/crank-import/tests/corpus/representative-47.json new file mode 100644 index 0000000..44c7cfc --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-47.json @@ -0,0 +1,52 @@ +{ + "basePath": "/v1", + "consumes": [ + "application/json" + ], + "host": "api.example.test", + "info": { + "title": "Synthetic corpus 47", + "version": "1.0" + }, + "paths": { + "/items/47": { + "head": { + "operationId": "corpusOperation47", + "parameters": [ + { + "in": "header", + "name": "p47", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "synthetic success", + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "summary": "Synthetic operation 47", + "tags": [ + "corpus" + ] + } + } + }, + "produces": [ + "application/json" + ], + "schemes": [ + "https" + ], + "swagger": "2.0" +} diff --git a/crates/crank-import/tests/corpus/representative-48.json b/crates/crank-import/tests/corpus/representative-48.json new file mode 100644 index 0000000..c3028e0 --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-48.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 48", + "version": "1.0" + }, + "openapi": "3.0.3", + "paths": { + "/items/48": { + "options": { + "operationId": "corpusOperation48", + "parameters": [ + { + "in": "query", + "name": "p48", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 48", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/corpus/representative-49.json b/crates/crank-import/tests/corpus/representative-49.json new file mode 100644 index 0000000..04b444b --- /dev/null +++ b/crates/crank-import/tests/corpus/representative-49.json @@ -0,0 +1,50 @@ +{ + "info": { + "title": "Synthetic corpus 49", + "version": "1.0" + }, + "openapi": "3.1.0", + "paths": { + "/items/{p49}": { + "get": { + "operationId": "corpusOperation49", + "parameters": [ + { + "in": "path", + "name": "p49", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "201": { + "content": { + "application/json": { + "schema": { + "properties": { + "id": { + "type": "string" + } + }, + "type": "object" + } + } + }, + "description": "synthetic success" + } + }, + "summary": "Synthetic operation 49", + "tags": [ + "corpus" + ] + } + } + }, + "servers": [ + { + "url": "https://api.example.test/v1" + } + ] +} diff --git a/crates/crank-import/tests/path_parameter_inheritance.rs b/crates/crank-import/tests/path_parameter_inheritance.rs new file mode 100644 index 0000000..df940d5 --- /dev/null +++ b/crates/crank-import/tests/path_parameter_inheritance.rs @@ -0,0 +1,67 @@ +use crank_import::rest::{NormalizationConfig, SourceDigest, normalize_verified_document}; +use serde_json::{Value, json}; +use sha2::{Digest, Sha256}; + +#[test] +fn path_item_parameters_are_inherited_and_operation_parameters_override_by_name_and_location() { + for version in ["3.0.3", "3.1.0", "2.0"] { + let parameter = |name: &str, location: &str, kind: &str| { + if version == "2.0" { + json!({"name":name,"in":location,"required":location == "path","type":kind}) + } else { + json!({"name":name,"in":location,"required":location == "path","schema":{"type":kind}}) + } + }; + let mut document = if version == "2.0" { + json!({"swagger":"2.0","info":{"title":"Path parameters","version":"1"}}) + } else { + json!({"openapi":version,"info":{"title":"Path parameters","version":"1"},"servers":[{"url":"https://example.test"}]}) + }; + document["paths"] = json!({ + "/items/{id}": { + "parameters": [parameter("id", "path", "string"), parameter("filter", "query", "string")], + "get": {"operationId":"readItem","responses":{"200":{"description":"ok"}}}, + "post": {"operationId":"updateItem","parameters":[parameter("filter", "query", "integer")], + "responses":{"200":{"description":"ok"}}} + } + }); + let source = serde_json::to_string(&document).unwrap(); + let digest = + SourceDigest::parse(format!("{:x}", Sha256::digest(source.as_bytes()))).unwrap(); + let ir = + normalize_verified_document(&source, digest, &NormalizationConfig::default()).unwrap(); + for (key, expected_kind) in [ + ("GET /items/{id}", "string"), + ("POST /items/{id}", "integer"), + ] { + let operation = ir + .operations + .iter() + .find(|operation| operation.key == key) + .unwrap(); + assert_eq!( + operation.parameters.len(), + 2, + "{version} {key}: {:?}", + operation.parameters + ); + let id = operation + .parameters + .iter() + .find(|parameter| parameter.name == "id") + .unwrap(); + assert_eq!(id.location, crank_import::rest::RestParameterLocation::Path); + let filter = operation + .parameters + .iter() + .find(|parameter| parameter.name == "filter") + .unwrap(); + let schema = serde_json::to_value(filter.schema.as_ref().unwrap()).unwrap(); + assert_eq!( + schema["kind"]["scalar_type"], + Value::String(expected_kind.to_owned()), + "{version} {key}: {schema}" + ); + } + } +} diff --git a/crates/crank-import/tests/security_scope.rs b/crates/crank-import/tests/security_scope.rs new file mode 100644 index 0000000..77d46fc --- /dev/null +++ b/crates/crank-import/tests/security_scope.rs @@ -0,0 +1,689 @@ +//! Focused regressions for the effective security scope +//! (story 2.14 review findings): +//! +//! - an OR array with an empty requirement object `{}` exposes the public +//! alternative and must keep the affected operation actionable, without +//! touching other operations; +//! - a single non-empty requirement must remain a blocker (regression anchor); +//! - malformed security shapes (non-array value, non-object array item) must +//! produce a source-located operation blocker instead of silently +//! disappearing. + +use crank_import::rest::{ + ImportFindingSeverity, ImportOperationCandidate, NormalizationConfig, NormalizedFinding, + SourceDigest, normalize_verified_document, preview_from_ir, +}; +use serde_json::{Value, json}; +use sha2::{Digest, Sha256}; + +fn hex(bytes: impl AsRef<[u8]>) -> String { + Sha256::digest(bytes) + .iter() + .map(|b| format!("{b:02x}")) + .collect() +} + +fn run( + source: &Value, +) -> ( + crank_import::rest::NormalizedIr, + crank_import::rest::ImportPreview, +) { + let text = serde_json::to_string(source).unwrap(); + let source_digest = SourceDigest::parse(hex(text.as_bytes())).expect("sha256 is valid"); + let ir = normalize_verified_document(&text, source_digest, &NormalizationConfig::default()) + .expect("security-scope fixture parses"); + let preview = preview_from_ir(&ir); + (ir, preview) +} + +fn candidate<'a>( + preview: &'a crank_import::rest::ImportPreview, + key: &str, +) -> &'a ImportOperationCandidate { + preview + .groups + .iter() + .flat_map(|group| &group.operations) + .find(|candidate| candidate.key == key) + .unwrap_or_else(|| panic!("{key} candidate missing in {preview:?}")) +} + +fn security_findings<'a>( + findings: &'a [NormalizedFinding], + key: &str, +) -> Vec<&'a NormalizedFinding> { + findings + .iter() + .filter(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + && finding.operation_key.as_deref() == Some(key) + }) + .collect() +} + +#[test] +fn empty_or_alternative_makes_the_operation_public() { + // Document-level OR array: [{"probe": []}, {}] offers an explicit public + // alternative, so the inherited operation must stay actionable. + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "components": { + "securitySchemes": { "probe": { "type": "http", "scheme": "basic" } } + }, + "security": [{ "probe": [] }, {}], + "paths": { + "/public": { "get": { "operationId": "publicInherit", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + let public = candidate(&preview, "GET /public"); + assert!( + public + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error), + "empty OR alternative must keep the inherited operation public: {:?}", + public.findings + ); + assert!( + security_findings(&ir.findings, "GET /public").is_empty(), + "no security blocker may belong to the public operation: {:?}", + ir.findings + ); + assert!( + preview.findings.iter().all(|finding| { + !(finding.severity == ImportFindingSeverity::Error && finding.operation_key.is_none()) + }), + "no document-global blocker may be produced: {preview:?}" + ); +} +#[test] +fn or_alternative_keeps_only_that_operation_public() { + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "components": { + "securitySchemes": { "probe": { "type": "http", "scheme": "basic" } } + }, + "paths": { + "/open": { "get": { "security": [{ "probe": [] }, {}], "operationId": "openOp", + "responses": { "200": { "description": "ok" } } } }, + "/closed": { "get": { "security": [{ "probe": [] }], "operationId": "closedOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + let open = candidate(&preview, "GET /open"); + assert!( + open.findings + .iter() + .all(|finding| { finding.severity != ImportFindingSeverity::Error }), + "operation with a public OR alternative must stay actionable: {:?}", + open.findings + ); + let closed = candidate(&preview, "GET /closed"); + assert!( + closed.findings.iter().any(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + }), + "non-empty requirement must still block the candidate: {:?}", + closed.findings + ); + let ir_blocker = security_findings(&ir.findings, "GET /closed")[0]; + assert_eq!( + ir_blocker.location.pointer, "/paths/~1closed/get/security/0", + "blocker must point at the local requirement: {:?}", + ir_blocker + ); + assert!( + security_findings(&ir.findings, "GET /closed").len() == 1, + "exactly one blocker for the closed operation: {:?}", + ir.findings + ); + assert!( + security_findings(&ir.findings, "GET /open").is_empty(), + "the public alternative must not leak into the open operation: {:?}", + ir.findings + ); +} + +#[test] +fn nonempty_requirement_still_blocks_with_auth_profile_contract() { + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "components": { + "securitySchemes": { "probe": { "type": "http", "scheme": "basic" } } + }, + "security": [{ "probe": [] }], + "paths": { + "/secured": { "get": { "operationId": "securedOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + let blocker = security_findings(&ir.findings, "GET /secured") + .into_iter() + .next() + .cloned() + .unwrap_or_else(|| panic!("non-empty requirement must block: {:?}", ir.findings)); + assert_eq!(blocker.location.pointer, "/security/0"); + assert_eq!( + blocker.message, + "Требование безопасности должно быть привязано к настроенному Auth Profile перед публикацией этой операции; остальные операции не блокируются.", + "Auth Profile contract message must be stable" + ); + let secured = candidate(&preview, "GET /secured"); + assert!( + secured.findings.iter().any(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + }), + "blocked candidate must expose the blocker: {:?}", + secured.findings + ); +} + +#[test] +fn malformed_security_shapes_block_the_affected_operation() { + // Non-array security value: both inherited operations are affected. + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "security": "basic", + "paths": { + "/one": { "get": { "operationId": "oneOp", + "responses": { "200": { "description": "ok" } } } }, + "/two": { "get": { "operationId": "twoOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + for key in ["GET /one", "GET /two"] { + let blocker = security_findings(&ir.findings, key) + .into_iter() + .next() + .cloned() + .unwrap_or_else(|| panic!("non-array security must block {key}: {:?}", ir.findings)); + assert_eq!( + blocker.location.pointer, "/security", + "blocker must point at the malformed root security: {:?}", + blocker + ); + assert!( + candidate(&preview, key).findings.iter().any(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + }), + "{key} candidate must be blocked" + ); + } + + // Non-object array item: the item pointer must be preserved. + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "security": ["basic"], + "paths": { + "/one": { "get": { "operationId": "oneOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, _) = run(&source); + let blocker = security_findings(&ir.findings, "GET /one") + .into_iter() + .next() + .cloned() + .unwrap_or_else(|| panic!("non-object security item must block: {:?}", ir.findings)); + assert_eq!( + blocker.location.pointer, "/security/0", + "blocker must point at the malformed item: {:?}", + blocker + ); + + // Malformed operation-level security must not affect the neighbour. + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "paths": { + "/bad": { "get": { "security": "basic", "operationId": "badOp", + "responses": { "200": { "description": "ok" } } } }, + "/fine": { "get": { "operationId": "fineOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + let blocker = security_findings(&ir.findings, "GET /bad") + .into_iter() + .next() + .cloned() + .unwrap_or_else(|| panic!("malformed local security must block: {:?}", ir.findings)); + assert_eq!( + blocker.location.pointer, "/paths/~1bad/get/security", + "blocker must point at the malformed local security: {:?}", + blocker + ); + assert!( + security_findings(&ir.findings, "GET /fine").is_empty(), + "the neighbour operation must not inherit a local defect: {:?}", + ir.findings + ); + assert!( + candidate(&preview, "GET /fine") + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error), + "neighbour operation must stay actionable" + ); +} + +#[test] +fn empty_alternative_needs_a_well_formed_array() { + // A malformed item in the same array invalidates the public + // alternative: every alternative is reported, and the operation + // stays blocked instead of silently becoming public. + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "components": { + "securitySchemes": { "probe": { "type": "http", "scheme": "basic" } } + }, + "security": [{ "probe": [] }, {}, "basic"], + "paths": { + "/mixed": { "get": { "operationId": "mixedOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + let at_item = |pointer: &str| { + ir.findings + .iter() + .find(|finding| { + finding.code == "unsupported_security_requirement" + && finding.operation_key.as_deref() == Some("GET /mixed") + && finding.location.pointer == pointer + }) + .unwrap_or_else(|| panic!("blocker at {pointer} missing: {:?}", ir.findings)) + }; + let secured = at_item("/security/0"); + assert_eq!( + secured.message, + "Требование безопасности должно быть привязано к настроенному Auth Profile перед публикацией этой операции; остальные операции не блокируются." + ); + let malformed = at_item("/security/2"); + assert_eq!( + malformed.message, + "security содержит альтернативу без объекта требований: формат не поддерживается, операция не публикуется." + ); + assert!( + candidate(&preview, "GET /mixed") + .findings + .iter() + .any(|finding| finding.severity == ImportFindingSeverity::Error), + "the operation must not become public because of a malformed sibling: {preview:?}" + ); +} + +fn security_fixture_31() -> serde_json::Map { + security_fixture_openapi("3.1.0") +} + +#[test] +fn object_instead_of_security_array_has_scoped_coverage() { + for version in ["3.0.3", "3.1.0", "2.0"] { + for local in [false, true] { + let mut fixture = if version == "2.0" { + security_fixture_swagger2() + } else { + security_fixture_openapi(version) + }; + if !local { + fixture.insert("security".to_owned(), json!({})); + } + fixture.insert( + "paths".to_owned(), + json!({ + "/bad": get200("badObject", local.then(|| json!({}))), + "/public": get200("publicObject", Some(json!([]))) + }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + let expected = if local { + "/paths/~1bad/get/security" + } else { + "/security" + }; + let blocker = security_findings(&ir.findings, "GET /bad"); + assert_eq!(blocker.len(), 1, "{version} {local}: {:?}", ir.findings); + assert_eq!(blocker[0].location.pointer, expected); + assert!(security_findings(&ir.findings, "GET /public").is_empty()); + assert!( + candidate(&preview, "GET /public") + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error) + ); + crank_import::rest::validate_normalized_ir(&ir).unwrap(); + } + } +} + +fn security_fixture_openapi(version: &str) -> serde_json::Map { + let mut fixture = serde_json::Map::new(); + fixture.insert("openapi".to_owned(), json!(version)); + fixture.insert( + "info".to_owned(), + json!({ "title": "Security scope regression", "version": "1" }), + ); + fixture.insert( + "servers".to_owned(), + json!([{ "url": "https://security-scope.example.test" }]), + ); + fixture +} + +fn security_fixture_swagger2() -> serde_json::Map { + let mut fixture = serde_json::Map::new(); + fixture.insert("swagger".to_owned(), json!("2.0")); + fixture.insert( + "info".to_owned(), + json!({ "title": "Security scope regression" }), + ); + fixture.insert("host".to_owned(), json!("security-scope.example.test")); + fixture.insert("schemes".to_owned(), json!(["https"])); + fixture +} + +fn get200(operation_id: &str, security: Option) -> Value { + let mut get = serde_json::Map::from_iter([ + ("operationId".to_owned(), json!(operation_id)), + ( + "responses".to_owned(), + json!({ "200": { "description": "ok" } }), + ), + ]); + if let Some(security) = security { + get.insert("security".to_owned(), security); + } + let mut path_item = serde_json::Map::new(); + path_item.insert("get".to_owned(), Value::Object(get)); + Value::Object(path_item) +} + +#[test] +fn openapi_31_non_array_root_security_blocks_inherited_operations() { + let mut fixture = security_fixture_31(); + fixture.insert("security".to_owned(), json!("basic")); + fixture.insert( + "paths".to_owned(), + json!({ + "/one": get200("oneOp31", None), + "/two": get200("twoOp31", None) + }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + for key in ["GET /one", "GET /two"] { + let blockers = security_findings(&ir.findings, key); + assert_eq!( + blockers.len(), + 1, + "exactly one blocker for {key}: {:?}", + ir.findings + ); + let blocker = &blockers[0]; + assert_eq!( + blocker.code, "unsupported_security_requirement", + "stable finding code: {blocker:?}" + ); + assert_eq!( + blocker.severity, + ImportFindingSeverity::Error, + "stable finding severity: {blocker:?}" + ); + assert_eq!( + blocker.location.pointer, "/security", + "blocker must point at the malformed root security: {blocker:?}" + ); + assert!( + candidate(&preview, key).findings.iter().any(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + }), + "{key} candidate must be blocked" + ); + } +} + +#[test] +fn openapi_31_malformed_local_security_affects_only_that_operation() { + let mut fixture = security_fixture_31(); + // A well-formed root requirement proves priority: the malformed local + // security wins for /bad (no root blocker may be added), while /public + // relies on an explicit empty override to stay public. + fixture.insert("security".to_owned(), json!([{ "probe": [] }])); + fixture.insert( + "paths".to_owned(), + json!({ + "/bad": get200("badOp31", Some(json!("basic"))), + "/public": get200("publicOp31", Some(json!([]))) + }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + let blockers = security_findings(&ir.findings, "GET /bad"); + assert_eq!(blockers.len(), 1, "exactly one blocker: {:?}", ir.findings); + assert_eq!( + blockers[0].code, "unsupported_security_requirement", + "stable finding code" + ); + assert_eq!( + blockers[0].severity, + ImportFindingSeverity::Error, + "stable finding severity" + ); + assert_eq!( + blockers[0].location.pointer, "/paths/~1bad/get/security", + "blocker must point at the malformed local security: {:?}", + blockers[0] + ); + assert!( + security_findings(&ir.findings, "GET /public").is_empty(), + "the public neighbour must not inherit a local defect: {:?}", + ir.findings + ); + assert!( + candidate(&preview, "GET /public") + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error), + "public neighbour must stay actionable: {preview:?}" + ); +} + +#[test] +fn openapi_31_public_alternative_with_malformed_sibling_does_not_go_public() { + let mut fixture = security_fixture_31(); + fixture.insert("security".to_owned(), json!([{}, "basic"])); + fixture.insert( + "paths".to_owned(), + json!({ "/mixed": get200("mixedOp31", None) }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + let blockers = security_findings(&ir.findings, "GET /mixed"); + assert_eq!( + blockers.len(), + 1, + "only the malformed sibling blocks: {:?}", + ir.findings + ); + assert_eq!( + blockers[0].location.pointer, "/security/1", + "blocker must point at the non-object item: {:?}", + blockers[0] + ); + assert_eq!( + blockers[0].message, + "security содержит альтернативу без объекта требований: формат не поддерживается, операция не публикуется." + ); + assert!( + candidate(&preview, "GET /mixed") + .findings + .iter() + .any(|finding| finding.severity == ImportFindingSeverity::Error), + "the operation must not become public because of a malformed sibling: {preview:?}" + ); +} + +#[test] +fn swagger2_non_array_root_security_blocks_inherited_operations() { + let mut fixture = security_fixture_swagger2(); + fixture.insert("security".to_owned(), json!("apikey")); + fixture.insert( + "paths".to_owned(), + json!({ + "/one": get200("oneOpS2", None), + "/two": get200("twoOpS2", None) + }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + for key in ["GET /one", "GET /two"] { + let blockers = security_findings(&ir.findings, key); + assert_eq!( + blockers.len(), + 1, + "exactly one blocker for {key}: {:?}", + ir.findings + ); + let blocker = &blockers[0]; + assert_eq!( + blocker.code, "unsupported_security_requirement", + "stable finding code: {blocker:?}" + ); + assert_eq!( + blocker.severity, + ImportFindingSeverity::Error, + "stable finding severity: {blocker:?}" + ); + assert_eq!( + blocker.location.pointer, "/security", + "blocker must point at the malformed root security: {blocker:?}" + ); + assert!( + candidate(&preview, key).findings.iter().any(|finding| { + finding.code == "unsupported_security_requirement" + && finding.severity == ImportFindingSeverity::Error + }), + "{key} candidate must be blocked" + ); + } +} + +#[test] +fn swagger2_malformed_local_security_affects_only_that_operation() { + let mut fixture = security_fixture_swagger2(); + // A well-formed root requirement proves priority: the malformed local + // security wins for /bad (no root blocker may be added), while /public + // relies on an explicit empty override to stay public. + fixture.insert("security".to_owned(), json!([{ "apiKey": [] }])); + fixture.insert( + "paths".to_owned(), + json!({ + "/bad": get200("badOpS2", Some(json!("apikey"))), + "/public": get200("publicOpS2", Some(json!([]))) + }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + let blockers = security_findings(&ir.findings, "GET /bad"); + assert_eq!(blockers.len(), 1, "exactly one blocker: {:?}", ir.findings); + assert_eq!(blockers[0].code, "unsupported_security_requirement"); + assert_eq!(blockers[0].severity, ImportFindingSeverity::Error); + assert_eq!( + blockers[0].location.pointer, "/paths/~1bad/get/security", + "blocker must point at the malformed local security: {:?}", + blockers[0] + ); + assert!( + security_findings(&ir.findings, "GET /public").is_empty(), + "the public neighbour must not inherit a local defect: {:?}", + ir.findings + ); + assert!( + candidate(&preview, "GET /public") + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error), + "public neighbour must stay actionable: {preview:?}" + ); +} + +#[test] +fn swagger2_public_alternative_with_malformed_sibling_does_not_go_public() { + let mut fixture = security_fixture_swagger2(); + fixture.insert("security".to_owned(), json!([{}, "apikey"])); + fixture.insert( + "paths".to_owned(), + json!({ "/mixed": get200("mixedOpS2", None) }), + ); + let (ir, preview) = run(&Value::Object(fixture)); + let blockers = security_findings(&ir.findings, "GET /mixed"); + assert_eq!( + blockers.len(), + 1, + "only the malformed sibling blocks: {:?}", + ir.findings + ); + assert_eq!( + blockers[0].location.pointer, "/security/1", + "blocker must point at the non-object item: {:?}", + blockers[0] + ); + assert_eq!( + blockers[0].message, + "security содержит альтернативу без объекта требований: формат не поддерживается, операция не публикуется." + ); + assert!( + candidate(&preview, "GET /mixed") + .findings + .iter() + .any(|finding| finding.severity == ImportFindingSeverity::Error), + "the operation must not become public because of a malformed sibling: {preview:?}" + ); +} + +#[test] +fn empty_security_array_stays_public() { + let source = json!({ + "openapi": "3.0.3", + "info": { "title": "Security scope regression", "version": "1" }, + "servers": [{ "url": "https://security-scope.example.test" }], + "security": [{ "probe": [] }], + "paths": { + "/public": { "get": { "security": [], "operationId": "publicOp", + "responses": { "200": { "description": "ok" } } } } + } + }); + let (ir, preview) = run(&source); + assert!( + security_findings(&ir.findings, "GET /public").is_empty(), + "explicit empty override must stay public: {:?}", + ir.findings + ); + assert!( + candidate(&preview, "GET /public") + .findings + .iter() + .all(|finding| finding.severity != ImportFindingSeverity::Error), + "overridden operation must remain actionable" + ); +} diff --git a/crates/crank-import/tests/support-matrix.yaml b/crates/crank-import/tests/support-matrix.yaml new file mode 100644 index 0000000..abd7d36 --- /dev/null +++ b/crates/crank-import/tests/support-matrix.yaml @@ -0,0 +1,1923 @@ +matrix_version: 1.0.2 +compatibility_impact: "1.0.2 scopes security blockers to the effective per-operation requirement (document inheritance plus an explicit empty security override) and adds override/mixed-operation probes; no previously supported importer behavior was removed or accepted." +constructs: + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.get" + status: supported + preserved_semantics: "GET method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.post" + status: supported + preserved_semantics: "POST method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.put" + status: supported + preserved_semantics: "PUT method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.patch" + status: supported + preserved_semantics: "PATCH method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.delete" + status: supported + preserved_semantics: "DELETE method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.head" + status: supported + preserved_semantics: "HEAD method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.options" + status: supported + preserved_semantics: "OPTIONS method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "parameter.location.path" + status: supported + preserved_semantics: "path parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "parameter.location.query" + status: supported + preserved_semantics: "query parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "parameter.location.header" + status: supported + preserved_semantics: "header parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "parameter.location.cookie" + status: supported + preserved_semantics: "cookie parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "request_body.application/json" + status: supported + preserved_semantics: "application/json request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "request_body.application/x-www-form-urlencoded" + status: supported + preserved_semantics: "application/x-www-form-urlencoded request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "request_body.multipart/form-data" + status: supported + preserved_semantics: "multipart/form-data request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.200" + status: supported + preserved_semantics: "Success response status 200 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.201" + status: supported + preserved_semantics: "Success response status 201 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.202" + status: supported + preserved_semantics: "Success response status 202 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.203" + status: supported + preserved_semantics: "Success response status 203 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.204" + status: supported + preserved_semantics: "Success response status 204 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.205" + status: supported + preserved_semantics: "Success response status 205 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.206" + status: supported + preserved_semantics: "Success response status 206 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.207" + status: supported + preserved_semantics: "Success response status 207 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.208" + status: supported + preserved_semantics: "Success response status 208 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.209" + status: supported + preserved_semantics: "Success response status 209 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.210" + status: supported + preserved_semantics: "Success response status 210 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.211" + status: supported + preserved_semantics: "Success response status 211 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.212" + status: supported + preserved_semantics: "Success response status 212 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.213" + status: supported + preserved_semantics: "Success response status 213 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.214" + status: supported + preserved_semantics: "Success response status 214 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.215" + status: supported + preserved_semantics: "Success response status 215 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.216" + status: supported + preserved_semantics: "Success response status 216 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.217" + status: supported + preserved_semantics: "Success response status 217 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.218" + status: supported + preserved_semantics: "Success response status 218 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.219" + status: supported + preserved_semantics: "Success response status 219 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.220" + status: supported + preserved_semantics: "Success response status 220 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.221" + status: supported + preserved_semantics: "Success response status 221 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.222" + status: supported + preserved_semantics: "Success response status 222 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.223" + status: supported + preserved_semantics: "Success response status 223 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.224" + status: supported + preserved_semantics: "Success response status 224 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.225" + status: supported + preserved_semantics: "Success response status 225 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.226" + status: supported + preserved_semantics: "Success response status 226 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.227" + status: supported + preserved_semantics: "Success response status 227 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.228" + status: supported + preserved_semantics: "Success response status 228 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.229" + status: supported + preserved_semantics: "Success response status 229 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.230" + status: supported + preserved_semantics: "Success response status 230 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.231" + status: supported + preserved_semantics: "Success response status 231 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.232" + status: supported + preserved_semantics: "Success response status 232 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.233" + status: supported + preserved_semantics: "Success response status 233 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.234" + status: supported + preserved_semantics: "Success response status 234 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.235" + status: supported + preserved_semantics: "Success response status 235 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.236" + status: supported + preserved_semantics: "Success response status 236 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.237" + status: supported + preserved_semantics: "Success response status 237 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.238" + status: supported + preserved_semantics: "Success response status 238 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.239" + status: supported + preserved_semantics: "Success response status 239 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.240" + status: supported + preserved_semantics: "Success response status 240 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.241" + status: supported + preserved_semantics: "Success response status 241 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.242" + status: supported + preserved_semantics: "Success response status 242 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.243" + status: supported + preserved_semantics: "Success response status 243 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.244" + status: supported + preserved_semantics: "Success response status 244 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.245" + status: supported + preserved_semantics: "Success response status 245 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.246" + status: supported + preserved_semantics: "Success response status 246 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.247" + status: supported + preserved_semantics: "Success response status 247 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.248" + status: supported + preserved_semantics: "Success response status 248 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.249" + status: supported + preserved_semantics: "Success response status 249 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.250" + status: supported + preserved_semantics: "Success response status 250 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.251" + status: supported + preserved_semantics: "Success response status 251 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.252" + status: supported + preserved_semantics: "Success response status 252 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.253" + status: supported + preserved_semantics: "Success response status 253 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.254" + status: supported + preserved_semantics: "Success response status 254 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.255" + status: supported + preserved_semantics: "Success response status 255 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.256" + status: supported + preserved_semantics: "Success response status 256 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.257" + status: supported + preserved_semantics: "Success response status 257 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.258" + status: supported + preserved_semantics: "Success response status 258 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.259" + status: supported + preserved_semantics: "Success response status 259 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.260" + status: supported + preserved_semantics: "Success response status 260 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.261" + status: supported + preserved_semantics: "Success response status 261 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.262" + status: supported + preserved_semantics: "Success response status 262 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.263" + status: supported + preserved_semantics: "Success response status 263 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.264" + status: supported + preserved_semantics: "Success response status 264 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.265" + status: supported + preserved_semantics: "Success response status 265 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.266" + status: supported + preserved_semantics: "Success response status 266 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.267" + status: supported + preserved_semantics: "Success response status 267 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.268" + status: supported + preserved_semantics: "Success response status 268 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.269" + status: supported + preserved_semantics: "Success response status 269 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.270" + status: supported + preserved_semantics: "Success response status 270 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.271" + status: supported + preserved_semantics: "Success response status 271 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.272" + status: supported + preserved_semantics: "Success response status 272 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.273" + status: supported + preserved_semantics: "Success response status 273 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.274" + status: supported + preserved_semantics: "Success response status 274 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.275" + status: supported + preserved_semantics: "Success response status 275 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.276" + status: supported + preserved_semantics: "Success response status 276 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.277" + status: supported + preserved_semantics: "Success response status 277 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.278" + status: supported + preserved_semantics: "Success response status 278 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.279" + status: supported + preserved_semantics: "Success response status 279 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.280" + status: supported + preserved_semantics: "Success response status 280 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.281" + status: supported + preserved_semantics: "Success response status 281 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.282" + status: supported + preserved_semantics: "Success response status 282 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.283" + status: supported + preserved_semantics: "Success response status 283 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.284" + status: supported + preserved_semantics: "Success response status 284 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.285" + status: supported + preserved_semantics: "Success response status 285 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.286" + status: supported + preserved_semantics: "Success response status 286 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.287" + status: supported + preserved_semantics: "Success response status 287 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.288" + status: supported + preserved_semantics: "Success response status 288 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.289" + status: supported + preserved_semantics: "Success response status 289 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.290" + status: supported + preserved_semantics: "Success response status 290 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.291" + status: supported + preserved_semantics: "Success response status 291 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.292" + status: supported + preserved_semantics: "Success response status 292 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.293" + status: supported + preserved_semantics: "Success response status 293 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.294" + status: supported + preserved_semantics: "Success response status 294 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.295" + status: supported + preserved_semantics: "Success response status 295 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.296" + status: supported + preserved_semantics: "Success response status 296 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.297" + status: supported + preserved_semantics: "Success response status 297 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.298" + status: supported + preserved_semantics: "Success response status 298 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "response.299" + status: supported + preserved_semantics: "Success response status 299 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "reference.local" + status: supported + preserved_semantics: "$ref within the uploaded document resolves without network access." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "reference.external_allowlisted" + status: supported + preserved_semantics: "Materialized allowlisted external snapshot resolves by immutable URI and digest without runtime fetch." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "composition.allOf" + status: supported + preserved_semantics: "allOf members are merged while preserving property, required, and constraint semantics." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "composition.oneOf" + status: supported + preserved_semantics: "oneOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "composition.anyOf" + status: supported + preserved_semantics: "anyOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "security.bearer" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.0" + construct_id: "security.basic" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.0" + construct_id: "security.api_key" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.0" + construct_id: "security.override_empty" + status: supported + preserved_semantics: "An operation-level empty security array disables document inheritance; the operation remains an actionable candidate without a security blocker." + expected_finding: "none" + - specification_version: "OpenAPI 3.0" + construct_id: "security.mixed_operations" + status: unsupported + preserved_semantics: "Only the operation carrying an effective security requirement receives the source-located blocker; operations overriding it with an empty security array remain actionable." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.0" + construct_id: "media_type.application_xml.request" + status: unsupported + preserved_semantics: "XML request bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_xml_request_media_type" + - specification_version: "OpenAPI 3.0" + construct_id: "media_type.application_xml.response" + status: unsupported + preserved_semantics: "XML response bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_xml_response_media_type" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.trace" + status: unsupported + preserved_semantics: "TRACE operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" + - specification_version: "OpenAPI 3.0" + construct_id: "http.method.connect" + status: unsupported + preserved_semantics: "CONNECT operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.get" + status: supported + preserved_semantics: "GET method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.post" + status: supported + preserved_semantics: "POST method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.put" + status: supported + preserved_semantics: "PUT method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.patch" + status: supported + preserved_semantics: "PATCH method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.delete" + status: supported + preserved_semantics: "DELETE method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.head" + status: supported + preserved_semantics: "HEAD method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.options" + status: supported + preserved_semantics: "OPTIONS method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "parameter.location.path" + status: supported + preserved_semantics: "path parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "parameter.location.query" + status: supported + preserved_semantics: "query parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "parameter.location.header" + status: supported + preserved_semantics: "header parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "parameter.location.cookie" + status: supported + preserved_semantics: "cookie parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "request_body.application/json" + status: supported + preserved_semantics: "application/json request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "request_body.application/x-www-form-urlencoded" + status: supported + preserved_semantics: "application/x-www-form-urlencoded request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "request_body.multipart/form-data" + status: supported + preserved_semantics: "multipart/form-data request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.200" + status: supported + preserved_semantics: "Success response status 200 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.201" + status: supported + preserved_semantics: "Success response status 201 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.202" + status: supported + preserved_semantics: "Success response status 202 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.203" + status: supported + preserved_semantics: "Success response status 203 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.204" + status: supported + preserved_semantics: "Success response status 204 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.205" + status: supported + preserved_semantics: "Success response status 205 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.206" + status: supported + preserved_semantics: "Success response status 206 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.207" + status: supported + preserved_semantics: "Success response status 207 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.208" + status: supported + preserved_semantics: "Success response status 208 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.209" + status: supported + preserved_semantics: "Success response status 209 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.210" + status: supported + preserved_semantics: "Success response status 210 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.211" + status: supported + preserved_semantics: "Success response status 211 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.212" + status: supported + preserved_semantics: "Success response status 212 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.213" + status: supported + preserved_semantics: "Success response status 213 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.214" + status: supported + preserved_semantics: "Success response status 214 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.215" + status: supported + preserved_semantics: "Success response status 215 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.216" + status: supported + preserved_semantics: "Success response status 216 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.217" + status: supported + preserved_semantics: "Success response status 217 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.218" + status: supported + preserved_semantics: "Success response status 218 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.219" + status: supported + preserved_semantics: "Success response status 219 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.220" + status: supported + preserved_semantics: "Success response status 220 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.221" + status: supported + preserved_semantics: "Success response status 221 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.222" + status: supported + preserved_semantics: "Success response status 222 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.223" + status: supported + preserved_semantics: "Success response status 223 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.224" + status: supported + preserved_semantics: "Success response status 224 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.225" + status: supported + preserved_semantics: "Success response status 225 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.226" + status: supported + preserved_semantics: "Success response status 226 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.227" + status: supported + preserved_semantics: "Success response status 227 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.228" + status: supported + preserved_semantics: "Success response status 228 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.229" + status: supported + preserved_semantics: "Success response status 229 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.230" + status: supported + preserved_semantics: "Success response status 230 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.231" + status: supported + preserved_semantics: "Success response status 231 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.232" + status: supported + preserved_semantics: "Success response status 232 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.233" + status: supported + preserved_semantics: "Success response status 233 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.234" + status: supported + preserved_semantics: "Success response status 234 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.235" + status: supported + preserved_semantics: "Success response status 235 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.236" + status: supported + preserved_semantics: "Success response status 236 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.237" + status: supported + preserved_semantics: "Success response status 237 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.238" + status: supported + preserved_semantics: "Success response status 238 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.239" + status: supported + preserved_semantics: "Success response status 239 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.240" + status: supported + preserved_semantics: "Success response status 240 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.241" + status: supported + preserved_semantics: "Success response status 241 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.242" + status: supported + preserved_semantics: "Success response status 242 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.243" + status: supported + preserved_semantics: "Success response status 243 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.244" + status: supported + preserved_semantics: "Success response status 244 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.245" + status: supported + preserved_semantics: "Success response status 245 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.246" + status: supported + preserved_semantics: "Success response status 246 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.247" + status: supported + preserved_semantics: "Success response status 247 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.248" + status: supported + preserved_semantics: "Success response status 248 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.249" + status: supported + preserved_semantics: "Success response status 249 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.250" + status: supported + preserved_semantics: "Success response status 250 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.251" + status: supported + preserved_semantics: "Success response status 251 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.252" + status: supported + preserved_semantics: "Success response status 252 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.253" + status: supported + preserved_semantics: "Success response status 253 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.254" + status: supported + preserved_semantics: "Success response status 254 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.255" + status: supported + preserved_semantics: "Success response status 255 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.256" + status: supported + preserved_semantics: "Success response status 256 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.257" + status: supported + preserved_semantics: "Success response status 257 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.258" + status: supported + preserved_semantics: "Success response status 258 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.259" + status: supported + preserved_semantics: "Success response status 259 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.260" + status: supported + preserved_semantics: "Success response status 260 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.261" + status: supported + preserved_semantics: "Success response status 261 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.262" + status: supported + preserved_semantics: "Success response status 262 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.263" + status: supported + preserved_semantics: "Success response status 263 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.264" + status: supported + preserved_semantics: "Success response status 264 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.265" + status: supported + preserved_semantics: "Success response status 265 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.266" + status: supported + preserved_semantics: "Success response status 266 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.267" + status: supported + preserved_semantics: "Success response status 267 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.268" + status: supported + preserved_semantics: "Success response status 268 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.269" + status: supported + preserved_semantics: "Success response status 269 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.270" + status: supported + preserved_semantics: "Success response status 270 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.271" + status: supported + preserved_semantics: "Success response status 271 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.272" + status: supported + preserved_semantics: "Success response status 272 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.273" + status: supported + preserved_semantics: "Success response status 273 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.274" + status: supported + preserved_semantics: "Success response status 274 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.275" + status: supported + preserved_semantics: "Success response status 275 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.276" + status: supported + preserved_semantics: "Success response status 276 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.277" + status: supported + preserved_semantics: "Success response status 277 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.278" + status: supported + preserved_semantics: "Success response status 278 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.279" + status: supported + preserved_semantics: "Success response status 279 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.280" + status: supported + preserved_semantics: "Success response status 280 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.281" + status: supported + preserved_semantics: "Success response status 281 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.282" + status: supported + preserved_semantics: "Success response status 282 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.283" + status: supported + preserved_semantics: "Success response status 283 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.284" + status: supported + preserved_semantics: "Success response status 284 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.285" + status: supported + preserved_semantics: "Success response status 285 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.286" + status: supported + preserved_semantics: "Success response status 286 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.287" + status: supported + preserved_semantics: "Success response status 287 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.288" + status: supported + preserved_semantics: "Success response status 288 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.289" + status: supported + preserved_semantics: "Success response status 289 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.290" + status: supported + preserved_semantics: "Success response status 290 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.291" + status: supported + preserved_semantics: "Success response status 291 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.292" + status: supported + preserved_semantics: "Success response status 292 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.293" + status: supported + preserved_semantics: "Success response status 293 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.294" + status: supported + preserved_semantics: "Success response status 294 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.295" + status: supported + preserved_semantics: "Success response status 295 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.296" + status: supported + preserved_semantics: "Success response status 296 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.297" + status: supported + preserved_semantics: "Success response status 297 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.298" + status: supported + preserved_semantics: "Success response status 298 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "response.299" + status: supported + preserved_semantics: "Success response status 299 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "reference.local" + status: supported + preserved_semantics: "$ref within the uploaded document resolves without network access." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "reference.external_allowlisted" + status: supported + preserved_semantics: "Materialized allowlisted external snapshot resolves by immutable URI and digest without runtime fetch." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "composition.allOf" + status: supported + preserved_semantics: "allOf members are merged while preserving property, required, and constraint semantics." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "composition.oneOf" + status: supported + preserved_semantics: "oneOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "composition.anyOf" + status: supported + preserved_semantics: "anyOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "security.bearer" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.1" + construct_id: "security.basic" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.1" + construct_id: "security.api_key" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.1" + construct_id: "security.override_empty" + status: supported + preserved_semantics: "An operation-level empty security array disables document inheritance; the operation remains an actionable candidate without a security blocker." + expected_finding: "none" + - specification_version: "OpenAPI 3.1" + construct_id: "security.mixed_operations" + status: unsupported + preserved_semantics: "Only the operation carrying an effective security requirement receives the source-located blocker; operations overriding it with an empty security array remain actionable." + expected_finding: "unsupported_security_requirement" + - specification_version: "OpenAPI 3.1" + construct_id: "media_type.application_xml.request" + status: unsupported + preserved_semantics: "XML request bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_xml_request_media_type" + - specification_version: "OpenAPI 3.1" + construct_id: "media_type.application_xml.response" + status: unsupported + preserved_semantics: "XML response bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_xml_response_media_type" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.trace" + status: unsupported + preserved_semantics: "TRACE operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" + - specification_version: "OpenAPI 3.1" + construct_id: "http.method.connect" + status: unsupported + preserved_semantics: "CONNECT operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" + - specification_version: "Swagger 2.0" + construct_id: "http.method.get" + status: supported + preserved_semantics: "GET method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.post" + status: supported + preserved_semantics: "POST method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.put" + status: supported + preserved_semantics: "PUT method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.patch" + status: supported + preserved_semantics: "PATCH method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.delete" + status: supported + preserved_semantics: "DELETE method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.head" + status: supported + preserved_semantics: "HEAD method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "http.method.options" + status: supported + preserved_semantics: "OPTIONS method and source path are retained as the candidate HTTP method and source path." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "parameter.location.path" + status: supported + preserved_semantics: "path parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "parameter.location.query" + status: supported + preserved_semantics: "query parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "parameter.location.header" + status: supported + preserved_semantics: "header parameter name, schema, required flag, and source location are retained in the typed input mapping." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "parameter.location.cookie" + status: unsupported + preserved_semantics: "Swagger 2.0 cookie parameters are not imported as actionable Drafts." + expected_finding: "unsupported_cookie_parameter" + - specification_version: "Swagger 2.0" + construct_id: "request_body.application/json" + status: supported + preserved_semantics: "application/json request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "request_body.application/x-www-form-urlencoded" + status: supported + preserved_semantics: "application/x-www-form-urlencoded request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "request_body.multipart/form-data" + status: supported + preserved_semantics: "multipart/form-data request schema and content type are retained in the request contract." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.200" + status: supported + preserved_semantics: "Success response status 200 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.201" + status: supported + preserved_semantics: "Success response status 201 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.202" + status: supported + preserved_semantics: "Success response status 202 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.203" + status: supported + preserved_semantics: "Success response status 203 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.204" + status: supported + preserved_semantics: "Success response status 204 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.205" + status: supported + preserved_semantics: "Success response status 205 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.206" + status: supported + preserved_semantics: "Success response status 206 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.207" + status: supported + preserved_semantics: "Success response status 207 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.208" + status: supported + preserved_semantics: "Success response status 208 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.209" + status: supported + preserved_semantics: "Success response status 209 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.210" + status: supported + preserved_semantics: "Success response status 210 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.211" + status: supported + preserved_semantics: "Success response status 211 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.212" + status: supported + preserved_semantics: "Success response status 212 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.213" + status: supported + preserved_semantics: "Success response status 213 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.214" + status: supported + preserved_semantics: "Success response status 214 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.215" + status: supported + preserved_semantics: "Success response status 215 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.216" + status: supported + preserved_semantics: "Success response status 216 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.217" + status: supported + preserved_semantics: "Success response status 217 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.218" + status: supported + preserved_semantics: "Success response status 218 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.219" + status: supported + preserved_semantics: "Success response status 219 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.220" + status: supported + preserved_semantics: "Success response status 220 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.221" + status: supported + preserved_semantics: "Success response status 221 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.222" + status: supported + preserved_semantics: "Success response status 222 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.223" + status: supported + preserved_semantics: "Success response status 223 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.224" + status: supported + preserved_semantics: "Success response status 224 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.225" + status: supported + preserved_semantics: "Success response status 225 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.226" + status: supported + preserved_semantics: "Success response status 226 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.227" + status: supported + preserved_semantics: "Success response status 227 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.228" + status: supported + preserved_semantics: "Success response status 228 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.229" + status: supported + preserved_semantics: "Success response status 229 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.230" + status: supported + preserved_semantics: "Success response status 230 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.231" + status: supported + preserved_semantics: "Success response status 231 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.232" + status: supported + preserved_semantics: "Success response status 232 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.233" + status: supported + preserved_semantics: "Success response status 233 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.234" + status: supported + preserved_semantics: "Success response status 234 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.235" + status: supported + preserved_semantics: "Success response status 235 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.236" + status: supported + preserved_semantics: "Success response status 236 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.237" + status: supported + preserved_semantics: "Success response status 237 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.238" + status: supported + preserved_semantics: "Success response status 238 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.239" + status: supported + preserved_semantics: "Success response status 239 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.240" + status: supported + preserved_semantics: "Success response status 240 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.241" + status: supported + preserved_semantics: "Success response status 241 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.242" + status: supported + preserved_semantics: "Success response status 242 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.243" + status: supported + preserved_semantics: "Success response status 243 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.244" + status: supported + preserved_semantics: "Success response status 244 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.245" + status: supported + preserved_semantics: "Success response status 245 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.246" + status: supported + preserved_semantics: "Success response status 246 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.247" + status: supported + preserved_semantics: "Success response status 247 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.248" + status: supported + preserved_semantics: "Success response status 248 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.249" + status: supported + preserved_semantics: "Success response status 249 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.250" + status: supported + preserved_semantics: "Success response status 250 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.251" + status: supported + preserved_semantics: "Success response status 251 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.252" + status: supported + preserved_semantics: "Success response status 252 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.253" + status: supported + preserved_semantics: "Success response status 253 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.254" + status: supported + preserved_semantics: "Success response status 254 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.255" + status: supported + preserved_semantics: "Success response status 255 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.256" + status: supported + preserved_semantics: "Success response status 256 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.257" + status: supported + preserved_semantics: "Success response status 257 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.258" + status: supported + preserved_semantics: "Success response status 258 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.259" + status: supported + preserved_semantics: "Success response status 259 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.260" + status: supported + preserved_semantics: "Success response status 260 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.261" + status: supported + preserved_semantics: "Success response status 261 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.262" + status: supported + preserved_semantics: "Success response status 262 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.263" + status: supported + preserved_semantics: "Success response status 263 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.264" + status: supported + preserved_semantics: "Success response status 264 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.265" + status: supported + preserved_semantics: "Success response status 265 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.266" + status: supported + preserved_semantics: "Success response status 266 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.267" + status: supported + preserved_semantics: "Success response status 267 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.268" + status: supported + preserved_semantics: "Success response status 268 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.269" + status: supported + preserved_semantics: "Success response status 269 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.270" + status: supported + preserved_semantics: "Success response status 270 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.271" + status: supported + preserved_semantics: "Success response status 271 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.272" + status: supported + preserved_semantics: "Success response status 272 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.273" + status: supported + preserved_semantics: "Success response status 273 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.274" + status: supported + preserved_semantics: "Success response status 274 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.275" + status: supported + preserved_semantics: "Success response status 275 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.276" + status: supported + preserved_semantics: "Success response status 276 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.277" + status: supported + preserved_semantics: "Success response status 277 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.278" + status: supported + preserved_semantics: "Success response status 278 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.279" + status: supported + preserved_semantics: "Success response status 279 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.280" + status: supported + preserved_semantics: "Success response status 280 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.281" + status: supported + preserved_semantics: "Success response status 281 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.282" + status: supported + preserved_semantics: "Success response status 282 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.283" + status: supported + preserved_semantics: "Success response status 283 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.284" + status: supported + preserved_semantics: "Success response status 284 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.285" + status: supported + preserved_semantics: "Success response status 285 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.286" + status: supported + preserved_semantics: "Success response status 286 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.287" + status: supported + preserved_semantics: "Success response status 287 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.288" + status: supported + preserved_semantics: "Success response status 288 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.289" + status: supported + preserved_semantics: "Success response status 289 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.290" + status: supported + preserved_semantics: "Success response status 290 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.291" + status: supported + preserved_semantics: "Success response status 291 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.292" + status: supported + preserved_semantics: "Success response status 292 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.293" + status: supported + preserved_semantics: "Success response status 293 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.294" + status: supported + preserved_semantics: "Success response status 294 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.295" + status: supported + preserved_semantics: "Success response status 295 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.296" + status: supported + preserved_semantics: "Success response status 296 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.297" + status: supported + preserved_semantics: "Success response status 297 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.298" + status: supported + preserved_semantics: "Success response status 298 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "response.299" + status: supported + preserved_semantics: "Success response status 299 and its response schema are retained; bodyless responses stay bodyless." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "reference.local" + status: supported + preserved_semantics: "$ref within the uploaded document resolves without network access." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "reference.external_allowlisted" + status: supported + preserved_semantics: "Materialized allowlisted external snapshot resolves by immutable URI and digest without runtime fetch." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "composition.allOf" + status: supported + preserved_semantics: "allOf members are merged while preserving property, required, and constraint semantics." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "composition.oneOf" + status: supported + preserved_semantics: "oneOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "composition.anyOf" + status: supported + preserved_semantics: "anyOf alternatives remain explicit request/response variants." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "security.bearer" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "Swagger 2.0" + construct_id: "security.basic" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "Swagger 2.0" + construct_id: "security.api_key" + status: unsupported + preserved_semantics: "The source security requirement is retained as a blocker until an administrator selects a compatible Auth Profile; credentials are never copied into the import preview." + expected_finding: "unsupported_security_requirement" + - specification_version: "Swagger 2.0" + construct_id: "security.override_empty" + status: supported + preserved_semantics: "An operation-level empty security array disables document inheritance; the operation remains an actionable candidate without a security blocker." + expected_finding: "none" + - specification_version: "Swagger 2.0" + construct_id: "security.mixed_operations" + status: unsupported + preserved_semantics: "Only the operation carrying an effective security requirement receives the source-located blocker; operations overriding it with an empty security array remain actionable." + expected_finding: "unsupported_security_requirement" + - specification_version: "Swagger 2.0" + construct_id: "media_type.application_xml.request" + status: unsupported + preserved_semantics: "XML request bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_consumes" + - specification_version: "Swagger 2.0" + construct_id: "media_type.application_xml.response" + status: unsupported + preserved_semantics: "XML response bodies are unsupported as actionable Drafts." + expected_finding: "unsupported_produces" + - specification_version: "Swagger 2.0" + construct_id: "http.method.trace" + status: unsupported + preserved_semantics: "TRACE operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" + - specification_version: "Swagger 2.0" + construct_id: "http.method.connect" + status: unsupported + preserved_semantics: "CONNECT operations are excluded and reported as a source-located blocker." + expected_finding: "unsupported_http_method" diff --git a/docs/openapi-import.md b/docs/openapi-import.md index 1f8cd7d..da3a008 100644 --- a/docs/openapi-import.md +++ b/docs/openapi-import.md @@ -81,3 +81,22 @@ Semantic loss получает blocker с source location: такой candidate Новые imports используют `normalized-ir-v4` / `preview-v4`. Сохранённые v2/v3 jobs воспроизводят сохранённый preview, а legacy-v1 использует отдельную историческую projection. Обновление importer не меняет inputs существующих jobs. Другие форматы спецификаций и протоколов в Community-импорт не входят. + +## Нормативная матрица и regression corpus + +Машинная матрица версии `1.0.2` хранится в [`crates/crank-import/tests/support-matrix.yaml`](../crates/crank-import/tests/support-matrix.yaml); corpus version — `1.0.3`. Матрица фиксирует контракт отдельно для OpenAPI 3.0, OpenAPI 3.1 и Swagger 2.0. Acceptance test запускает нормализатор на отдельном probe для каждой строки, включая все 100 успешных кодов в каждом формате, и сверяет сохранённую semantics или точный blocker; выполненные probes списываются со всех строк версии, поэтому неподвергнутая проверкой строка матрицы падает gate. Версия corpus `1.0.3` добавляет hostile fixture `hostile-security-scope.json`: document-level требование безопасности блокирует только унаследовавшего его secured candidate (`GET /secure`, location `/security/0`), а операция с явным `security: []` (`GET /public`) остаётся actionable без глобального blocker; oversized hostile JSON остаётся тем же canonical JSON с ожидаемым parser rejection. + +| Конструкция | OpenAPI 3.0/3.1 | Swagger 2.0 | Сохраняемый контракт или finding | +|---|---|---|---| +| `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `HEAD`, `OPTIONS` | Поддерживается | Поддерживается | Метод и исходный path переходят в Operation | +| `path`, `query`, `header`, `cookie` параметры | Поддерживается | `path`, `query`, `header` поддерживаются; `cookie` явно unsupported | Имя, schema, required и source location сохраняются; Swagger cookie получает `unsupported_cookie_parameter` | +| JSON, urlencoded, multipart | Поддерживается | Поддерживается по `consumes`/body parameter | Schema и content type остаются частью request contract | +| Успешные `2xx`, включая `204` | Поддерживается | Поддерживается | Каждая строка 200–299 проверяется отдельным probe; status сохраняется, а 204/205 остаются bodyless | +| Локальные и allowlisted external `$ref` | Поддерживается | Поддерживается | Разрешение только из загруженного документа или digest-проверенного snapshot; тесты не загружают fixture по сети | +| `allOf`, `oneOf`, `anyOf` | Поддерживается | Поддерживается | Совместимые `allOf` ветви объединяются; `oneOf` и `anyOf` остаются вариантами schema | +| bearer/basic/API key security requirements | Blocker до выбора Auth Profile | Blocker до выбора Auth Profile | `unsupported_security_requirement`; requirement вычисляется per-operation с наследованием document-уровня; credentials не импортируются и не попадают в preview | +| security override: operation-level `security: []` | Поддерживается | Поддерживается | Явный пустой массив отключает наследование: только operations с эффективным requirement получают source-located blocker, связанные операции остаются actionable | +| Микс public/secured operations | Поддерживается | Подвергается проверке | Blocker принадлежит только затронутому candidate; global blocker не создаётся для требований одного operation | +| XML, `TRACE`, `CONNECT` | Unsupported | Unsupported | Source-located finding; blocker не становится actionable Draft | + +Offline corpus в `crates/crank-import/tests/corpus/` содержит 50 synthetic representative документов и hostile subset. Manifest фиксирует SHA-256 исходных файлов, canonical digest JSON, происхождение и лицензию; для representative документов он также фиксирует полный canonical preview и frozen candidates (schemas, mappings, actionable/blocker), а для hostile — ожидаемые отказы и findings. Команда `just openapi-corpus` прогоняет настоящий normalizer, сравнивает независимо перечисленные raw source pointers с canonical source tree и coverage ledger, проверяет порог 95% actionable от всех representative Operations и отдельно нулевой silent loss. Evidence связывает digest manifest и matrix, включает content digest и создаётся без перезаписи; конфликт содержимого для того же identity останавливает gate. CI прикладывает `crates/crank-import/target/openapi-corpus/evidence-.json`. Artifact не содержит загруженный исходник или значения secret-like examples. diff --git a/justfile b/justfile index 1d312c5..7a796b3 100644 --- a/justfile +++ b/justfile @@ -44,6 +44,12 @@ clippy: test: cargo test --workspace --all-targets -- --test-threads=1 +openapi-corpus: + cargo test -p crank-import --test corpus -- --test-threads=1 + +openapi-matrix-compat base: + python3 scripts/check-openapi-matrix-compatibility.py --base "{{base}}" + sqlx-prepare database_url: DATABASE_URL={{database_url}} cargo sqlx prepare --workspace -- --all-targets diff --git a/scripts/check-openapi-matrix-compatibility.py b/scripts/check-openapi-matrix-compatibility.py new file mode 100755 index 0000000..09a9f94 --- /dev/null +++ b/scripts/check-openapi-matrix-compatibility.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python3 +"""Require versioned, explained compatibility changes to OpenAPI contracts.""" + +from __future__ import annotations + +import argparse +import json +import re +import subprocess +import sys +from typing import Any + +MATRIX_PATH = "crates/crank-import/tests/support-matrix.yaml" +MANIFEST_PATH = "crates/crank-import/tests/corpus/manifest.json" +DOCS_PATH = "docs/openapi-import.md" + + +def git_show(revision: str, path: str) -> str | None: + result = subprocess.run( + ["git", "show", f"{revision}:{path}"], + check=False, + capture_output=True, + text=True, + ) + return result.stdout if result.returncode == 0 else None + + +def matrix_version(contents: str | None) -> str | None: + if contents is None: + return None + match = re.search(r"(?m)^matrix_version:\s*['\"]?([^\s'\"]+)", contents) + return match.group(1) if match else None + + +def parse_manifest(contents: str | None, label: str) -> dict[str, Any] | None: + if contents is None: + return None + try: + value = json.loads(contents) + except json.JSONDecodeError as error: + raise ValueError(f"{label} is not valid JSON: {error}") from error + if not isinstance(value, dict): + raise ValueError(f"{label} must be a JSON object") + return value + + +def require(condition: bool, message: str, errors: list[str]) -> None: + if not condition: + errors.append(message) + + +def valid_version(value: Any) -> bool: + return isinstance(value, str) and re.fullmatch( + r"(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)", value + ) is not None + + +def version_increases(old: Any, new: Any) -> bool: + """Compare the numeric contract versions used by the matrix and corpus.""" + if not valid_version(old) or not valid_version(new): + return False + return tuple(map(int, new.split("."))) > tuple(map(int, old.split("."))) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base", required=True, help="base commit or ref to compare against") + args = parser.parse_args() + + try: + subprocess.run( + ["git", "rev-parse", "--verify", f"{args.base}^{{commit}}"], + check=True, + capture_output=True, + text=True, + ) + except subprocess.CalledProcessError: + print(f"OpenAPI compatibility guard: base revision {args.base!r} is unavailable", file=sys.stderr) + return 2 + + try: + old_matrix_text = git_show(args.base, MATRIX_PATH) + old_manifest_text = git_show(args.base, MANIFEST_PATH) + with open(MATRIX_PATH, encoding="utf-8") as matrix_file: + new_matrix_text = matrix_file.read() + with open(MANIFEST_PATH, encoding="utf-8") as manifest_file: + new_manifest_text = manifest_file.read() + with open(DOCS_PATH, encoding="utf-8") as docs_file: + new_docs_text = docs_file.read() + old_manifest = parse_manifest(old_manifest_text, "base manifest") + new_manifest = parse_manifest(new_manifest_text, "working manifest") + except (OSError, ValueError) as error: + print(f"OpenAPI compatibility guard: {error}", file=sys.stderr) + return 2 + + matrix_changed = old_matrix_text != new_matrix_text + manifest_changed = old_manifest_text != new_manifest_text + + errors: list[str] = [] + old_matrix_version = matrix_version(old_matrix_text) + new_matrix_version = matrix_version(new_matrix_text) + new_corpus_version = new_manifest.get("corpus_version") + new_impact = new_manifest.get("compatibility_impact") + require(bool(new_matrix_version), "support matrix must declare matrix_version", errors) + require(bool(new_corpus_version), "corpus manifest must declare corpus_version", errors) + require(valid_version(new_matrix_version), "matrix_version must be numeric SemVer", errors) + require(valid_version(new_corpus_version), "corpus_version must be numeric SemVer", errors) + require( + new_manifest.get("matrix_version") == new_matrix_version, + "manifest matrix_version must match support matrix", + errors, + ) + require( + isinstance(new_impact, str) and bool(new_impact.strip()), + "corpus manifest must include a non-empty compatibility_impact note", + errors, + ) + + if matrix_changed and old_matrix_text is not None: + require( + version_increases(old_matrix_version, new_matrix_version), + "support-matrix.yaml changed without a matrix_version bump (must increase SemVer)", + errors, + ) + + old_matrix_was_present = old_matrix_text is not None + if matrix_changed and old_matrix_was_present: + old_impact = old_manifest.get("compatibility_impact") if old_manifest else None + require( + new_impact != old_impact, + "support matrix changed without updating compatibility_impact", + errors, + ) + + # The published documentation states concrete matrix/corpus versions; + # a stale or mixed version in docs must not outlive the machine source. + matrix_decls = re.findall( + r"матриц[аы] версии `([0-9]+\.[0-9]+\.[0-9]+)`", new_docs_text, re.IGNORECASE + ) + corpus_decls = re.findall( + r"corpus version — `([0-9]+\.[0-9]+\.[0-9]+)`", new_docs_text, re.IGNORECASE + ) + require( + bool(matrix_decls) and all(version == new_matrix_version for version in matrix_decls), + f"{DOCS_PATH} matrix version declaration must state matrix_version {new_matrix_version}", + errors, + ) + require( + bool(corpus_decls) and all(version == new_corpus_version for version in corpus_decls), + f"{DOCS_PATH} corpus version declaration must state corpus_version {new_corpus_version}", + errors, + ) + require( + bool(matrix_decls) and bool(corpus_decls) + and all(version == new_matrix_version for version in matrix_decls) + and all(version == new_corpus_version for version in corpus_decls), + f"{DOCS_PATH} must state the current support matrix and corpus versions", + errors, + ) + if old_manifest is not None: + if old_manifest != new_manifest: + require( + version_increases(old_manifest.get("corpus_version"), new_corpus_version), + "corpus manifest changed without a corpus_version bump (must increase SemVer)", + errors, + ) + require( + new_impact != old_manifest.get("compatibility_impact"), + "corpus manifest changed without updating compatibility_impact", + errors, + ) + if errors: + print("OpenAPI compatibility guard failed:", file=sys.stderr) + for error in errors: + print(f"- {error}", file=sys.stderr) + return 1 + + print( + "OpenAPI compatibility guard passed: " + f"matrix {old_matrix_version or ''} -> {new_matrix_version}; " + f"corpus {old_manifest.get('corpus_version') if old_manifest else ''} -> {new_corpus_version}" + ) + if not matrix_changed and not manifest_changed: + print("OpenAPI compatibility guard: matrix and corpus manifest are unchanged") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/unit/test_check_openapi_matrix_compatibility.py b/tests/unit/test_check_openapi_matrix_compatibility.py new file mode 100644 index 0000000..16479a1 --- /dev/null +++ b/tests/unit/test_check_openapi_matrix_compatibility.py @@ -0,0 +1,271 @@ +import json +import subprocess +import tempfile +import unittest +from pathlib import Path + + +SCRIPT = Path(__file__).parents[2] / "scripts" / "check-openapi-matrix-compatibility.py" + +MATRIX_PATH = "crates/crank-import/tests/support-matrix.yaml" +MANIFEST_PATH = "crates/crank-import/tests/corpus/manifest.json" +DOCS_PATH = "docs/openapi-import.md" + +BASE_MATRIX = """matrix_version: '1.0.0' +constructs: + - id: baseline +""" +BASE_DOC = "Матрица версии `1.0.0`; corpus version — `1.0.0`.\n" + + +def base_manifest() -> dict: + return { + "corpus_version": "1.0.0", + "matrix_version": "1.0.0", + "compatibility_impact": "initial contract", + "documents": [ + { + "id": "rep-00", + "file": "representative-00.json", + "sha256": "a" * 64, + "origin": "synthetic:cc0", + "license": "CC0-1.0", + "specification_version": "OpenAPI 3.0", + "classification": "representative", + "expected_preview": {}, + } + ], + } + + +class OpenApiMatrixCompatibilityGuardTests(unittest.TestCase): + def setUp(self) -> None: + self._directory = tempfile.TemporaryDirectory() + self.root = Path(self._directory.name) + subprocess.run( + ["git", "init", "-q"], cwd=self.root, check=True, capture_output=True + ) + for relative in (MATRIX_PATH, MANIFEST_PATH, DOCS_PATH): + target = self.root / relative + target.parent.mkdir(parents=True, exist_ok=True) + (self.root / MATRIX_PATH).write_text(BASE_MATRIX, encoding="utf-8") + (self.root / MANIFEST_PATH).write_text( + json.dumps(base_manifest()), encoding="utf-8" + ) + (self.root / DOCS_PATH).write_text(BASE_DOC, encoding="utf-8") + self.commit("base") + self.base = self.head() + + def tearDown(self) -> None: + self._directory.cleanup() + + def self_git(self, *args: str) -> None: + subprocess.run( + ["git", "-c", "user.email=guard@test", "-c", "user.name=guard", *args], + cwd=self.root, + check=True, + capture_output=True, + ) + + def commit(self, message: str) -> None: + self.self_git("add", "-A") + self.self_git("commit", "-m", message) + + def head(self) -> str: + result = subprocess.run( + ["git", "rev-parse", "HEAD"], + cwd=self.root, + check=True, + capture_output=True, + text=True, + ) + return result.stdout.strip() + + def run_guard(self) -> subprocess.CompletedProcess[str]: + return subprocess.run( + ["python3", str(SCRIPT), "--base", self.base], + cwd=self.root, + text=True, + capture_output=True, + check=False, + ) + + def test_rejects_docs_only_edit_with_stale_version(self) -> None: + # matrix and manifest are untouched relative to the base, but a docs + # edit that pins a stale contract version must still be rejected + (self.root / DOCS_PATH).write_text( + "Матрица версии `0.9.0`; corpus version — `0.9.0`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn( + "must state the current support matrix and corpus versions", result.stderr + ) + + def test_rejects_docs_with_reversed_matrix_and_corpus_versions(self) -> None: + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX.replace("'1.0.0'", "'1.1.0'") + " - id: addition\n", + encoding="utf-8", + ) + manifest = base_manifest() + manifest["matrix_version"] = "1.1.0" + manifest["corpus_version"] = "1.0.1" + manifest["compatibility_impact"] = "bumped release" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `1.0.1`; corpus version — `1.1.0`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn( + "matrix version declaration must state matrix_version 1.1.0", result.stderr + ) + + def test_rejects_contract_change_without_version_bump_on_existing_base(self) -> None: + # The base already contains the contract: appending a matrix row must be + # rejected even though the versions and impact note stay untouched. + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX + " - id: addition\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("changed without a matrix_version bump", result.stderr) + self.assertIn("without updating compatibility_impact", result.stderr) + + def test_rejects_matrix_version_downgrade(self) -> None: + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX.replace("'1.0.0'", "'0.9.0'") + " - id: addition\n", + encoding="utf-8", + ) + manifest = base_manifest() + manifest["matrix_version"] = "0.9.0" + manifest["compatibility_impact"] = "downgraded matrix" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `0.9.0`; corpus version — `1.0.0`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("matrix_version bump (must increase SemVer)", result.stderr) + + def test_rejects_manifest_change_without_corpus_bump_on_existing_base(self) -> None: + manifest = base_manifest() + manifest["documents"][0]["file"] = "representative-99.json" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("without a corpus_version bump", result.stderr) + self.assertIn("without updating compatibility_impact", result.stderr) + + def test_rejects_corpus_version_downgrade(self) -> None: + manifest = base_manifest() + manifest["corpus_version"] = "0.9.0" + manifest["compatibility_impact"] = "downgraded corpus" + manifest["documents"][0]["file"] = "representative-99.json" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `1.0.0`; corpus version — `0.9.0`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("corpus_version bump (must increase SemVer)", result.stderr) + + def test_rejects_stale_versions_in_published_docs(self) -> None: + matrix = BASE_MATRIX.replace("'1.0.0'", "'1.1.0'") + " - id: addition\n" + (self.root / MATRIX_PATH).write_text(matrix, encoding="utf-8") + manifest = base_manifest() + manifest["matrix_version"] = "1.1.0" + manifest["corpus_version"] = "1.0.1" + manifest["compatibility_impact"] = "matrix 1.1.0 release" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + # docs still pin the previous `1.0.0` release + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("must state the current support matrix and corpus versions", result.stderr) + + def test_rejects_docs_citing_versions_missing_from_release(self) -> None: + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX + " - id: addition\n", encoding="utf-8" + ) + manifest = base_manifest() + manifest["matrix_version"] = "1.1.0" + manifest["corpus_version"] = "1.1.0" + manifest["compatibility_impact"] = "matrix 1.1.0 release" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `1.1.0`; corpus version — `0.9.0`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("must state the current support matrix and corpus versions", result.stderr) + + def test_allows_other_semver_in_docs(self) -> None: + (self.root / DOCS_PATH).write_text( + "Матрица версии `1.0.0`; corpus version — `1.0.0`. OpenAPI `3.1.0`.\n", + encoding="utf-8", + ) + result = self.run_guard() + self.assertEqual(result.returncode, 0, result.stderr) + + def test_rejects_conflicting_second_version_declaration(self) -> None: + (self.root / DOCS_PATH).write_text( + BASE_DOC + "Матрица версии `0.9.0`; corpus version — `0.9.0`.\n", + encoding="utf-8", + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("must state the current support matrix and corpus versions", result.stderr) + + def test_rejects_leading_zero_in_contract_version(self) -> None: + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX.replace("'1.0.0'", "'01.0.1'") + " - id: addition\n", + encoding="utf-8", + ) + manifest = base_manifest() + manifest["matrix_version"] = "01.0.1" + manifest["compatibility_impact"] = "invalid version" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `01.0.1`; corpus version — `1.0.0`.\n", + encoding="utf-8", + ) + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("matrix_version bump (must increase SemVer)", result.stderr) + + def test_rejects_manifest_metadata_change_without_bump(self) -> None: + manifest = base_manifest() + manifest["canonical_digest_definition"] = "changed contract" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("without a corpus_version bump", result.stderr) + + def test_rejects_corpus_version_only_downgrade(self) -> None: + manifest = base_manifest() + manifest["corpus_version"] = "0.9.0" + manifest["compatibility_impact"] = "downgrade" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + result = self.run_guard() + self.assertEqual(result.returncode, 1, result.stderr) + self.assertIn("corpus_version bump (must increase SemVer)", result.stderr) + + def test_passes_consistent_bumped_release_with_updated_docs(self) -> None: + (self.root / MATRIX_PATH).write_text( + BASE_MATRIX.replace("'1.0.0'", "'1.1.0'") + " - id: addition\n", + encoding="utf-8", + ) + manifest = base_manifest() + manifest["matrix_version"] = "1.1.0" + manifest["corpus_version"] = "1.0.1" + manifest["compatibility_impact"] = "matrix 1.1.0 release" + (self.root / MANIFEST_PATH).write_text(json.dumps(manifest), encoding="utf-8") + (self.root / DOCS_PATH).write_text( + "Матрица версии `1.1.0`; corpus version — `1.0.1`.\n", encoding="utf-8" + ) + result = self.run_guard() + self.assertEqual(result.returncode, 0, result.stderr) + + +if __name__ == "__main__": + unittest.main()