Content here...
Main Title
+Paragraph content
+- Item 1
- Item 2
Sample text
" + result3 = await crawler.arun(f"raw:{raw_html}") + + # All return the same CrawlResult structure + for i, result in enumerate([result1, result2, result3], 1): + if result.success: + print(f"Input {i}: {len(result.markdown)} chars of markdown") + +# Save and re-process HTML example +async def save_and_reprocess(): + async with AsyncWebCrawler() as crawler: + # Original crawl + result = await crawler.arun("https://example.com") + + if result.success: + # Save HTML to file + with open("saved_page.html", "w", encoding="utf-8") as f: + f.write(result.html) + + # Re-process from file + file_result = await crawler.arun("file://./saved_page.html") + + # Process as raw HTML + raw_result = await crawler.arun(f"raw:{result.html}") + + # Verify consistency + assert len(result.markdown) == len(file_result.markdown) == len(raw_result.markdown) + print("✅ All processing methods produced identical results") +``` + +### Advanced Link & Media Handling + +```python +# Comprehensive link and media extraction with filtering +async def advanced_link_media_handling(): + config = CrawlerRunConfig( + # Link filtering + exclude_external_links=False, # Keep external links for analysis + exclude_social_media_links=True, + exclude_domains=["ads.com", "tracker.io", "spammy.net"], + + # Media handling + exclude_external_images=True, + image_score_threshold=5, # Only high-quality images + table_score_threshold=7, # Only well-structured tables + wait_for_images=True, + + # Capture additional formats + screenshot=True, + pdf=True, + capture_mhtml=True # Full page archive + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://example.com", config=config) + + if result.success: + # Analyze links + internal_links = result.links.get("internal", []) + external_links = result.links.get("external", []) + print(f"Links: {len(internal_links)} internal, {len(external_links)} external") + + # Analyze media + images = result.media.get("images", []) + tables = result.media.get("tables", []) + print(f"Media: {len(images)} images, {len(tables)} tables") + + # High-quality images only + quality_images = [img for img in images if img.get("score", 0) >= 5] + print(f"High-quality images: {len(quality_images)}") + + # Table analysis + for i, table in enumerate(tables[:2]): + print(f"Table {i+1}: {len(table.get('headers', []))} columns, {len(table.get('rows', []))} rows") + + # Save captured files + if result.screenshot: + import base64 + with open("page_screenshot.png", "wb") as f: + f.write(base64.b64decode(result.screenshot)) + + if result.pdf: + with open("page.pdf", "wb") as f: + f.write(result.pdf) + + if result.mhtml: + with open("page_archive.mhtml", "w", encoding="utf-8") as f: + f.write(result.mhtml) + + print("Additional formats saved: screenshot, PDF, MHTML archive") +``` + +### Performance & Resource Management + +```python +# Optimize performance for large-scale crawling +async def performance_optimized_crawling(): + # Lightweight browser config + browser_config = BrowserConfig( + headless=True, + text_mode=True, # Disable images for speed + light_mode=True, # Reduce background features + extra_args=["--disable-extensions", "--no-sandbox"] + ) + + # Efficient crawl config + config = CrawlerRunConfig( + # Content filtering for speed + excluded_tags=["script", "style", "nav", "footer"], + exclude_external_links=True, + exclude_all_images=True, # Remove all images for max speed + word_count_threshold=50, + + # Timing optimizations + page_timeout=30000, # Faster timeout + delay_before_return_html=0.1, + + # Resource monitoring + capture_network_requests=False, # Disable unless needed + capture_console_messages=False, + + # Cache for repeated URLs + cache_mode=CacheMode.ENABLED + ) + + async with AsyncWebCrawler(config=browser_config) as crawler: + urls = ["https://example.com/page1", "https://example.com/page2", "https://example.com/page3"] + + # Efficient batch processing + batch_config = config.clone( + stream=True, # Stream results as they complete + semaphore_count=3 # Control concurrency + ) + + async for result in await crawler.arun_many(urls, config=batch_config): + if result.success: + print(f"✅ {result.url}: {len(result.markdown)} chars") + else: + print(f"❌ {result.url}: {result.error_message}") +``` + + +**📖 Learn more:** [Complete Parameter Reference](https://docs.crawl4ai.com/api/parameters/), [Content Filtering](https://docs.crawl4ai.com/core/markdown-generation/), [Session Management](https://docs.crawl4ai.com/advanced/session-management/), [Network Capture](https://docs.crawl4ai.com/advanced/network-console-capture/) + +**📖 Learn more:** [Hooks & Authentication](https://docs.crawl4ai.com/advanced/hooks-auth/), [Session Management](https://docs.crawl4ai.com/advanced/session-management/), [Network Monitoring](https://docs.crawl4ai.com/advanced/network-console-capture/), [Page Interaction](https://docs.crawl4ai.com/core/page-interaction/), [File Downloads](https://docs.crawl4ai.com/advanced/file-downloading/) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/deep_crawl_advanced_filters_scorers.txt b/docs/md_v2/assets/llm.txt/txt/deep_crawl_advanced_filters_scorers.txt new file mode 100644 index 00000000..52bac1ae --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/deep_crawl_advanced_filters_scorers.txt @@ -0,0 +1,446 @@ +## Deep Crawling Filters & Scorers + +Advanced URL filtering and scoring strategies for intelligent deep crawling with performance optimization. + +### URL Filters - Content and Domain Control + +```python +from crawl4ai.deep_crawling.filters import ( + URLPatternFilter, DomainFilter, ContentTypeFilter, + FilterChain, ContentRelevanceFilter, SEOFilter +) + +# Pattern-based filtering +pattern_filter = URLPatternFilter( + patterns=[ + "*.html", # HTML pages only + "*/blog/*", # Blog posts + "*/articles/*", # Article pages + "*2024*", # Recent content + "^https://example.com/docs/.*" # Regex pattern + ], + use_glob=True, + reverse=False # False = include matching, True = exclude matching +) + +# Domain filtering with subdomains +domain_filter = DomainFilter( + allowed_domains=["example.com", "docs.example.com"], + blocked_domains=["ads.example.com", "tracker.com"] +) + +# Content type filtering +content_filter = ContentTypeFilter( + allowed_types=["text/html", "application/pdf"], + check_extension=True +) + +# Apply individual filters +url = "https://example.com/blog/2024/article.html" +print(f"Pattern filter: {pattern_filter.apply(url)}") +print(f"Domain filter: {domain_filter.apply(url)}") +print(f"Content filter: {content_filter.apply(url)}") +``` + +### Filter Chaining - Combine Multiple Filters + +```python +# Create filter chain for comprehensive filtering +filter_chain = FilterChain([ + DomainFilter(allowed_domains=["example.com"]), + URLPatternFilter(patterns=["*/blog/*", "*/docs/*"]), + ContentTypeFilter(allowed_types=["text/html"]) +]) + +# Apply chain to URLs +urls = [ + "https://example.com/blog/post1.html", + "https://spam.com/content.html", + "https://example.com/blog/image.jpg", + "https://example.com/docs/guide.html" +] + +async def filter_urls(urls, filter_chain): + filtered = [] + for url in urls: + if await filter_chain.apply(url): + filtered.append(url) + return filtered + +# Usage +filtered_urls = await filter_urls(urls, filter_chain) +print(f"Filtered URLs: {filtered_urls}") + +# Check filter statistics +for filter_obj in filter_chain.filters: + stats = filter_obj.stats + print(f"{filter_obj.name}: {stats.passed_urls}/{stats.total_urls} passed") +``` + +### Advanced Content Filters + +```python +# BM25-based content relevance filtering +relevance_filter = ContentRelevanceFilter( + query="python machine learning tutorial", + threshold=0.5, # Minimum relevance score + k1=1.2, # TF saturation parameter + b=0.75, # Length normalization + avgdl=1000 # Average document length +) + +# SEO quality filtering +seo_filter = SEOFilter( + threshold=0.65, # Minimum SEO score + keywords=["python", "tutorial", "guide"], + weights={ + "title_length": 0.15, + "title_kw": 0.18, + "meta_description": 0.12, + "canonical": 0.10, + "robot_ok": 0.20, + "schema_org": 0.10, + "url_quality": 0.15 + } +) + +# Apply advanced filters +url = "https://example.com/python-ml-tutorial" +relevance_score = await relevance_filter.apply(url) +seo_score = await seo_filter.apply(url) + +print(f"Relevance: {relevance_score}, SEO: {seo_score}") +``` + +### URL Scorers - Quality and Relevance Scoring + +```python +from crawl4ai.deep_crawling.scorers import ( + KeywordRelevanceScorer, PathDepthScorer, ContentTypeScorer, + FreshnessScorer, DomainAuthorityScorer, CompositeScorer +) + +# Keyword relevance scoring +keyword_scorer = KeywordRelevanceScorer( + keywords=["python", "tutorial", "guide", "machine", "learning"], + weight=1.0, + case_sensitive=False +) + +# Path depth scoring (optimal depth = 3) +depth_scorer = PathDepthScorer( + optimal_depth=3, # /category/subcategory/article + weight=0.8 +) + +# Content type scoring +content_type_scorer = ContentTypeScorer( + type_weights={ + "html": 1.0, # Highest priority + "pdf": 0.8, # Medium priority + "txt": 0.6, # Lower priority + "doc": 0.4 # Lowest priority + }, + weight=0.9 +) + +# Freshness scoring +freshness_scorer = FreshnessScorer( + weight=0.7, + current_year=2024 +) + +# Domain authority scoring +domain_scorer = DomainAuthorityScorer( + domain_weights={ + "python.org": 1.0, + "github.com": 0.9, + "stackoverflow.com": 0.85, + "medium.com": 0.7, + "personal-blog.com": 0.3 + }, + default_weight=0.5, + weight=1.0 +) + +# Score individual URLs +url = "https://python.org/tutorial/2024/machine-learning.html" +scores = { + "keyword": keyword_scorer.score(url), + "depth": depth_scorer.score(url), + "content": content_type_scorer.score(url), + "freshness": freshness_scorer.score(url), + "domain": domain_scorer.score(url) +} + +print(f"Individual scores: {scores}") +``` + +### Composite Scoring - Combine Multiple Scorers + +```python +# Create composite scorer combining all strategies +composite_scorer = CompositeScorer( + scorers=[ + KeywordRelevanceScorer(["python", "tutorial"], weight=1.5), + PathDepthScorer(optimal_depth=3, weight=1.0), + ContentTypeScorer({"html": 1.0, "pdf": 0.8}, weight=1.2), + FreshnessScorer(weight=0.8, current_year=2024), + DomainAuthorityScorer({ + "python.org": 1.0, + "github.com": 0.9 + }, weight=1.3) + ], + normalize=True # Normalize by number of scorers +) + +# Score multiple URLs +urls_to_score = [ + "https://python.org/tutorial/2024/basics.html", + "https://github.com/user/python-guide/blob/main/README.md", + "https://random-blog.com/old/2018/python-stuff.html", + "https://python.org/docs/deep/nested/advanced/guide.html" +] + +scored_urls = [] +for url in urls_to_score: + score = composite_scorer.score(url) + scored_urls.append((url, score)) + +# Sort by score (highest first) +scored_urls.sort(key=lambda x: x[1], reverse=True) + +for url, score in scored_urls: + print(f"Score: {score:.3f} - {url}") + +# Check scorer statistics +print(f"\nScoring statistics:") +print(f"URLs scored: {composite_scorer.stats._urls_scored}") +print(f"Average score: {composite_scorer.stats.get_average():.3f}") +``` + +### Advanced Filter Patterns + +```python +# Complex pattern matching +advanced_patterns = URLPatternFilter( + patterns=[ + r"^https://docs\.python\.org/\d+/", # Python docs with version + r".*/tutorial/.*\.html$", # Tutorial pages + r".*/guide/(?!deprecated).*", # Guides but not deprecated + "*/blog/{2020,2021,2022,2023,2024}/*", # Recent blog posts + "**/{api,reference}/**/*.html" # API/reference docs + ], + use_glob=True +) + +# Exclude patterns (reverse=True) +exclude_filter = URLPatternFilter( + patterns=[ + "*/admin/*", + "*/login/*", + "*/private/*", + "**/.*", # Hidden files + "*.{jpg,png,gif,css,js}$" # Media and assets + ], + reverse=True # Exclude matching patterns +) + +# Content type with extension mapping +detailed_content_filter = ContentTypeFilter( + allowed_types=["text", "application"], + check_extension=True, + ext_map={ + "html": "text/html", + "htm": "text/html", + "md": "text/markdown", + "pdf": "application/pdf", + "doc": "application/msword", + "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document" + } +) +``` + +### Performance-Optimized Filtering + +```python +# High-performance filter chain for large-scale crawling +class OptimizedFilterChain: + def __init__(self): + # Fast filters first (domain, patterns) + self.fast_filters = [ + DomainFilter( + allowed_domains=["example.com", "docs.example.com"], + blocked_domains=["ads.example.com"] + ), + URLPatternFilter([ + "*.html", "*.pdf", "*/blog/*", "*/docs/*" + ]) + ] + + # Slower filters last (content analysis) + self.slow_filters = [ + ContentRelevanceFilter( + query="important content", + threshold=0.3 + ) + ] + + async def apply_optimized(self, url: str) -> bool: + # Apply fast filters first + for filter_obj in self.fast_filters: + if not filter_obj.apply(url): + return False + + # Only apply slow filters if fast filters pass + for filter_obj in self.slow_filters: + if not await filter_obj.apply(url): + return False + + return True + +# Batch filtering with concurrency +async def batch_filter_urls(urls, filter_chain, max_concurrent=50): + import asyncio + semaphore = asyncio.Semaphore(max_concurrent) + + async def filter_single(url): + async with semaphore: + return await filter_chain.apply(url), url + + tasks = [filter_single(url) for url in urls] + results = await asyncio.gather(*tasks) + + return [url for passed, url in results if passed] + +# Usage with 1000 URLs +large_url_list = [f"https://example.com/page{i}.html" for i in range(1000)] +optimized_chain = OptimizedFilterChain() +filtered = await batch_filter_urls(large_url_list, optimized_chain) +``` + +### Custom Filter Implementation + +```python +from crawl4ai.deep_crawling.filters import URLFilter +import re + +class CustomLanguageFilter(URLFilter): + """Filter URLs by language indicators""" + + def __init__(self, allowed_languages=["en"], weight=1.0): + super().__init__() + self.allowed_languages = set(allowed_languages) + self.lang_patterns = { + "en": re.compile(r"/en/|/english/|lang=en"), + "es": re.compile(r"/es/|/spanish/|lang=es"), + "fr": re.compile(r"/fr/|/french/|lang=fr"), + "de": re.compile(r"/de/|/german/|lang=de") + } + + def apply(self, url: str) -> bool: + # Default to English if no language indicators + if not any(pattern.search(url) for pattern in self.lang_patterns.values()): + result = "en" in self.allowed_languages + self._update_stats(result) + return result + + # Check for allowed languages + for lang in self.allowed_languages: + if lang in self.lang_patterns: + if self.lang_patterns[lang].search(url): + self._update_stats(True) + return True + + self._update_stats(False) + return False + +# Custom scorer implementation +from crawl4ai.deep_crawling.scorers import URLScorer + +class CustomComplexityScorer(URLScorer): + """Score URLs by content complexity indicators""" + + def __init__(self, weight=1.0): + super().__init__(weight) + self.complexity_indicators = { + "tutorial": 0.9, + "guide": 0.8, + "example": 0.7, + "reference": 0.6, + "api": 0.5 + } + + def _calculate_score(self, url: str) -> float: + url_lower = url.lower() + max_score = 0.0 + + for indicator, score in self.complexity_indicators.items(): + if indicator in url_lower: + max_score = max(max_score, score) + + return max_score + +# Use custom filters and scorers +custom_filter = CustomLanguageFilter(allowed_languages=["en", "es"]) +custom_scorer = CustomComplexityScorer(weight=1.2) + +url = "https://example.com/en/tutorial/advanced-guide.html" +passes_filter = custom_filter.apply(url) +complexity_score = custom_scorer.score(url) + +print(f"Passes language filter: {passes_filter}") +print(f"Complexity score: {complexity_score}") +``` + +### Integration with Deep Crawling + +```python +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig +from crawl4ai.deep_crawling import DeepCrawlStrategy + +async def deep_crawl_with_filtering(): + # Create comprehensive filter chain + filter_chain = FilterChain([ + DomainFilter(allowed_domains=["python.org"]), + URLPatternFilter(["*/tutorial/*", "*/guide/*", "*/docs/*"]), + ContentTypeFilter(["text/html"]), + SEOFilter(threshold=0.6, keywords=["python", "programming"]) + ]) + + # Create composite scorer + scorer = CompositeScorer([ + KeywordRelevanceScorer(["python", "tutorial"], weight=1.5), + FreshnessScorer(weight=0.8), + PathDepthScorer(optimal_depth=3, weight=1.0) + ], normalize=True) + + # Configure deep crawl strategy with filters and scorers + deep_strategy = DeepCrawlStrategy( + max_depth=3, + max_pages=100, + url_filter=filter_chain, + url_scorer=scorer, + score_threshold=0.6 # Only crawl URLs scoring above 0.6 + ) + + config = CrawlerRunConfig( + deep_crawl_strategy=deep_strategy, + cache_mode=CacheMode.BYPASS + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun( + url="https://python.org", + config=config + ) + + print(f"Deep crawl completed: {result.success}") + if hasattr(result, 'deep_crawl_results'): + print(f"Pages crawled: {len(result.deep_crawl_results)}") + +# Run the deep crawl +await deep_crawl_with_filtering() +``` + +**📖 Learn more:** [Deep Crawling Strategy](https://docs.crawl4ai.com/core/deep-crawling/), [Custom Filter Development](https://docs.crawl4ai.com/advanced/custom-filters/), [Performance Optimization](https://docs.crawl4ai.com/advanced/performance-tuning/) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/deep_crawling.txt b/docs/md_v2/assets/llm.txt/txt/deep_crawling.txt new file mode 100644 index 00000000..45c72e88 --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/deep_crawling.txt @@ -0,0 +1,348 @@ +## Deep Crawling + +Multi-level website exploration with intelligent filtering, scoring, and prioritization strategies. + +### Basic Deep Crawl Setup + +```python +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig +from crawl4ai.deep_crawling import BFSDeepCrawlStrategy +from crawl4ai.content_scraping_strategy import LXMLWebScrapingStrategy + +# Basic breadth-first deep crawling +async def basic_deep_crawl(): + config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy( + max_depth=2, # Initial page + 2 levels + include_external=False # Stay within same domain + ), + scraping_strategy=LXMLWebScrapingStrategy(), + verbose=True + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun("https://docs.crawl4ai.com", config=config) + + # Group results by depth + pages_by_depth = {} + for result in results: + depth = result.metadata.get("depth", 0) + if depth not in pages_by_depth: + pages_by_depth[depth] = [] + pages_by_depth[depth].append(result.url) + + print(f"Crawled {len(results)} pages total") + for depth, urls in sorted(pages_by_depth.items()): + print(f"Depth {depth}: {len(urls)} pages") +``` + +### Deep Crawl Strategies + +```python +from crawl4ai.deep_crawling import BFSDeepCrawlStrategy, DFSDeepCrawlStrategy, BestFirstCrawlingStrategy +from crawl4ai.deep_crawling.scorers import KeywordRelevanceScorer + +# Breadth-First Search - explores all links at one depth before going deeper +bfs_strategy = BFSDeepCrawlStrategy( + max_depth=2, + include_external=False, + max_pages=50, # Limit total pages + score_threshold=0.3 # Minimum score for URLs +) + +# Depth-First Search - explores as deep as possible before backtracking +dfs_strategy = DFSDeepCrawlStrategy( + max_depth=2, + include_external=False, + max_pages=30, + score_threshold=0.5 +) + +# Best-First - prioritizes highest scoring pages (recommended) +keyword_scorer = KeywordRelevanceScorer( + keywords=["crawl", "example", "async", "configuration"], + weight=0.7 +) + +best_first_strategy = BestFirstCrawlingStrategy( + max_depth=2, + include_external=False, + url_scorer=keyword_scorer, + max_pages=25 # No score_threshold needed - naturally prioritizes +) + +# Usage +config = CrawlerRunConfig( + deep_crawl_strategy=best_first_strategy, # Choose your strategy + scraping_strategy=LXMLWebScrapingStrategy() +) +``` + +### Streaming vs Batch Processing + +```python +# Batch mode - wait for all results +async def batch_deep_crawl(): + config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy(max_depth=1), + stream=False # Default - collect all results first + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun("https://example.com", config=config) + + # Process all results at once + for result in results: + print(f"Batch processed: {result.url}") + +# Streaming mode - process results as they arrive +async def streaming_deep_crawl(): + config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy(max_depth=1), + stream=True # Process results immediately + ) + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun("https://example.com", config=config): + depth = result.metadata.get("depth", 0) + print(f"Stream processed depth {depth}: {result.url}") +``` + +### Filtering with Filter Chains + +```python +from crawl4ai.deep_crawling.filters import ( + FilterChain, + URLPatternFilter, + DomainFilter, + ContentTypeFilter, + SEOFilter, + ContentRelevanceFilter +) + +# Single URL pattern filter +url_filter = URLPatternFilter(patterns=["*core*", "*guide*"]) + +config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy( + max_depth=1, + filter_chain=FilterChain([url_filter]) + ) +) + +# Multiple filters in chain +advanced_filter_chain = FilterChain([ + # Domain filtering + DomainFilter( + allowed_domains=["docs.example.com"], + blocked_domains=["old.docs.example.com", "staging.example.com"] + ), + + # URL pattern matching + URLPatternFilter(patterns=["*tutorial*", "*guide*", "*blog*"]), + + # Content type filtering + ContentTypeFilter(allowed_types=["text/html"]), + + # SEO quality filter + SEOFilter( + threshold=0.5, + keywords=["tutorial", "guide", "documentation"] + ), + + # Content relevance filter + ContentRelevanceFilter( + query="Web crawling and data extraction with Python", + threshold=0.7 + ) +]) + +config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy( + max_depth=2, + filter_chain=advanced_filter_chain + ) +) +``` + +### Intelligent Crawling with Scorers + +```python +from crawl4ai.deep_crawling.scorers import KeywordRelevanceScorer + +# Keyword relevance scoring +async def scored_deep_crawl(): + keyword_scorer = KeywordRelevanceScorer( + keywords=["browser", "crawler", "web", "automation"], + weight=1.0 + ) + + config = CrawlerRunConfig( + deep_crawl_strategy=BestFirstCrawlingStrategy( + max_depth=2, + include_external=False, + url_scorer=keyword_scorer + ), + stream=True, # Recommended with BestFirst + verbose=True + ) + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun("https://docs.crawl4ai.com", config=config): + score = result.metadata.get("score", 0) + depth = result.metadata.get("depth", 0) + print(f"Depth: {depth} | Score: {score:.2f} | {result.url}") +``` + +### Limiting Crawl Size + +```python +# Max pages limitation across strategies +async def limited_crawls(): + # BFS with page limit + bfs_config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy( + max_depth=2, + max_pages=5, # Only crawl 5 pages total + url_scorer=KeywordRelevanceScorer(keywords=["browser", "crawler"], weight=1.0) + ) + ) + + # DFS with score threshold + dfs_config = CrawlerRunConfig( + deep_crawl_strategy=DFSDeepCrawlStrategy( + max_depth=2, + score_threshold=0.7, # Only URLs with scores above 0.7 + max_pages=10, + url_scorer=KeywordRelevanceScorer(keywords=["web", "automation"], weight=1.0) + ) + ) + + # Best-First with both constraints + bf_config = CrawlerRunConfig( + deep_crawl_strategy=BestFirstCrawlingStrategy( + max_depth=2, + max_pages=7, # Automatically gets highest scored pages + url_scorer=KeywordRelevanceScorer(keywords=["crawl", "example"], weight=1.0) + ), + stream=True + ) + + async with AsyncWebCrawler() as crawler: + # Use any of the configs + async for result in await crawler.arun("https://docs.crawl4ai.com", config=bf_config): + score = result.metadata.get("score", 0) + print(f"Score: {score:.2f} | {result.url}") +``` + +### Complete Advanced Deep Crawler + +```python +async def comprehensive_deep_crawl(): + # Sophisticated filter chain + filter_chain = FilterChain([ + DomainFilter( + allowed_domains=["docs.crawl4ai.com"], + blocked_domains=["old.docs.crawl4ai.com"] + ), + URLPatternFilter(patterns=["*core*", "*advanced*", "*blog*"]), + ContentTypeFilter(allowed_types=["text/html"]), + SEOFilter(threshold=0.4, keywords=["crawl", "tutorial", "guide"]) + ]) + + # Multi-keyword scorer + keyword_scorer = KeywordRelevanceScorer( + keywords=["crawl", "example", "async", "configuration", "browser"], + weight=0.8 + ) + + # Complete configuration + config = CrawlerRunConfig( + deep_crawl_strategy=BestFirstCrawlingStrategy( + max_depth=2, + include_external=False, + filter_chain=filter_chain, + url_scorer=keyword_scorer, + max_pages=20 + ), + scraping_strategy=LXMLWebScrapingStrategy(), + stream=True, + verbose=True, + cache_mode=CacheMode.BYPASS + ) + + # Execute and analyze + results = [] + start_time = time.time() + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun("https://docs.crawl4ai.com", config=config): + results.append(result) + score = result.metadata.get("score", 0) + depth = result.metadata.get("depth", 0) + print(f"→ Depth: {depth} | Score: {score:.2f} | {result.url}") + + # Performance analysis + duration = time.time() - start_time + avg_score = sum(r.metadata.get('score', 0) for r in results) / len(results) + + print(f"✅ Crawled {len(results)} pages in {duration:.2f}s") + print(f"✅ Average relevance score: {avg_score:.2f}") + + # Depth distribution + depth_counts = {} + for result in results: + depth = result.metadata.get("depth", 0) + depth_counts[depth] = depth_counts.get(depth, 0) + 1 + + for depth, count in sorted(depth_counts.items()): + print(f"📊 Depth {depth}: {count} pages") +``` + +### Error Handling and Robustness + +```python +async def robust_deep_crawl(): + config = CrawlerRunConfig( + deep_crawl_strategy=BestFirstCrawlingStrategy( + max_depth=2, + max_pages=15, + url_scorer=KeywordRelevanceScorer(keywords=["guide", "tutorial"]) + ), + stream=True, + page_timeout=30000 # 30 second timeout per page + ) + + successful_pages = [] + failed_pages = [] + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun("https://docs.crawl4ai.com", config=config): + if result.success: + successful_pages.append(result) + depth = result.metadata.get("depth", 0) + score = result.metadata.get("score", 0) + print(f"✅ Depth {depth} | Score: {score:.2f} | {result.url}") + else: + failed_pages.append({ + 'url': result.url, + 'error': result.error_message, + 'depth': result.metadata.get("depth", 0) + }) + print(f"❌ Failed: {result.url} - {result.error_message}") + + print(f"📊 Results: {len(successful_pages)} successful, {len(failed_pages)} failed") + + # Analyze failures by depth + if failed_pages: + failure_by_depth = {} + for failure in failed_pages: + depth = failure['depth'] + failure_by_depth[depth] = failure_by_depth.get(depth, 0) + 1 + + print("❌ Failures by depth:") + for depth, count in sorted(failure_by_depth.items()): + print(f" Depth {depth}: {count} failures") +``` + +**📖 Learn more:** [Deep Crawling Guide](https://docs.crawl4ai.com/core/deep-crawling/), [Filter Documentation](https://docs.crawl4ai.com/core/content-selection/), [Scoring Strategies](https://docs.crawl4ai.com/advanced/advanced-features/) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/docker.txt b/docs/md_v2/assets/llm.txt/txt/docker.txt new file mode 100644 index 00000000..a4c55d8a --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/docker.txt @@ -0,0 +1,826 @@ +## Docker Deployment + +Complete Docker deployment guide with pre-built images, API endpoints, configuration, and MCP integration. + +### Quick Start with Pre-built Images + +```bash +# Pull latest image +docker pull unclecode/crawl4ai:latest + +# Setup LLM API keys +cat > .llm.env << EOL +OPENAI_API_KEY=sk-your-key +ANTHROPIC_API_KEY=your-anthropic-key +GROQ_API_KEY=your-groq-key +GEMINI_API_TOKEN=your-gemini-token +EOL + +# Run with LLM support +docker run -d \ + -p 11235:11235 \ + --name crawl4ai \ + --env-file .llm.env \ + --shm-size=1g \ + unclecode/crawl4ai:latest + +# Basic run (no LLM) +docker run -d \ + -p 11235:11235 \ + --name crawl4ai \ + --shm-size=1g \ + unclecode/crawl4ai:latest + +# Check health +curl http://localhost:11235/health +``` + +### Docker Compose Deployment + +```bash +# Clone and setup +git clone https://github.com/unclecode/crawl4ai.git +cd crawl4ai +cp deploy/docker/.llm.env.example .llm.env +# Edit .llm.env with your API keys + +# Run pre-built image +IMAGE=unclecode/crawl4ai:latest docker compose up -d + +# Build locally +docker compose up --build -d + +# Build with all features +INSTALL_TYPE=all docker compose up --build -d + +# Build with GPU support +ENABLE_GPU=true docker compose up --build -d + +# Stop service +docker compose down +``` + +### Manual Build with Multi-Architecture + +```bash +# Clone repository +git clone https://github.com/unclecode/crawl4ai.git +cd crawl4ai + +# Build for current architecture +docker buildx build -t crawl4ai-local:latest --load . + +# Build for multiple architectures +docker buildx build --platform linux/amd64,linux/arm64 \ + -t crawl4ai-local:latest --load . + +# Build with specific features +docker buildx build \ + --build-arg INSTALL_TYPE=all \ + --build-arg ENABLE_GPU=false \ + -t crawl4ai-local:latest --load . + +# Run custom build +docker run -d \ + -p 11235:11235 \ + --name crawl4ai-custom \ + --env-file .llm.env \ + --shm-size=1g \ + crawl4ai-local:latest +``` + +### Build Arguments + +```bash +# Available build options +docker buildx build \ + --build-arg INSTALL_TYPE=all \ # default|all|torch|transformer + --build-arg ENABLE_GPU=true \ # true|false + --build-arg APP_HOME=/app \ # Install path + --build-arg USE_LOCAL=true \ # Use local source + --build-arg GITHUB_REPO=url \ # Git repo if USE_LOCAL=false + --build-arg GITHUB_BRANCH=main \ # Git branch + -t crawl4ai-custom:latest --load . +``` + +### Core API Endpoints + +```python +# Main crawling endpoints +import requests +import json + +# Basic crawl +payload = { + "urls": ["https://example.com"], + "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, + "crawler_config": {"type": "CrawlerRunConfig", "params": {"cache_mode": "bypass"}} +} +response = requests.post("http://localhost:11235/crawl", json=payload) + +# Streaming crawl +payload["crawler_config"]["params"]["stream"] = True +response = requests.post("http://localhost:11235/crawl/stream", json=payload) + +# Health check +response = requests.get("http://localhost:11235/health") + +# API schema +response = requests.get("http://localhost:11235/schema") + +# Metrics (Prometheus format) +response = requests.get("http://localhost:11235/metrics") +``` + +### Specialized Endpoints + +```python +# HTML extraction (preprocessed for schema) +response = requests.post("http://localhost:11235/html", + json={"url": "https://example.com"}) + +# Screenshot capture +response = requests.post("http://localhost:11235/screenshot", json={ + "url": "https://example.com", + "screenshot_wait_for": 2, + "output_path": "/path/to/save/screenshot.png" +}) + +# PDF generation +response = requests.post("http://localhost:11235/pdf", json={ + "url": "https://example.com", + "output_path": "/path/to/save/document.pdf" +}) + +# JavaScript execution +response = requests.post("http://localhost:11235/execute_js", json={ + "url": "https://example.com", + "scripts": [ + "return document.title", + "return Array.from(document.querySelectorAll('a')).map(a => a.href)" + ] +}) + +# Markdown generation +response = requests.post("http://localhost:11235/md", json={ + "url": "https://example.com", + "f": "fit", # raw|fit|bm25|llm + "q": "extract main content", # query for filtering + "c": "0" # cache: 0=bypass, 1=use +}) + +# LLM Q&A +response = requests.get("http://localhost:11235/llm/https://example.com?q=What is this page about?") + +# Library context (for AI assistants) +response = requests.get("http://localhost:11235/ask", params={ + "context_type": "all", # code|doc|all + "query": "how to use extraction strategies", + "score_ratio": 0.5, + "max_results": 20 +}) +``` + +### Python SDK Usage + +```python +import asyncio +from crawl4ai.docker_client import Crawl4aiDockerClient +from crawl4ai import BrowserConfig, CrawlerRunConfig, CacheMode + +async def main(): + async with Crawl4aiDockerClient(base_url="http://localhost:11235") as client: + # Non-streaming crawl + results = await client.crawl( + ["https://example.com"], + browser_config=BrowserConfig(headless=True), + crawler_config=CrawlerRunConfig(cache_mode=CacheMode.BYPASS) + ) + + for result in results: + print(f"URL: {result.url}, Success: {result.success}") + print(f"Content length: {len(result.markdown)}") + + # Streaming crawl + stream_config = CrawlerRunConfig(stream=True, cache_mode=CacheMode.BYPASS) + async for result in await client.crawl( + ["https://example.com", "https://python.org"], + browser_config=BrowserConfig(headless=True), + crawler_config=stream_config + ): + print(f"Streamed: {result.url} - {result.success}") + + # Get API schema + schema = await client.get_schema() + print(f"Schema available: {bool(schema)}") + +asyncio.run(main()) +``` + +### Advanced API Configuration + +```python +# Complex extraction with LLM +payload = { + "urls": ["https://example.com"], + "browser_config": { + "type": "BrowserConfig", + "params": { + "headless": True, + "viewport": {"type": "dict", "value": {"width": 1200, "height": 800}} + } + }, + "crawler_config": { + "type": "CrawlerRunConfig", + "params": { + "extraction_strategy": { + "type": "LLMExtractionStrategy", + "params": { + "llm_config": { + "type": "LLMConfig", + "params": { + "provider": "openai/gpt-4o-mini", + "api_token": "env:OPENAI_API_KEY" + } + }, + "schema": { + "type": "dict", + "value": { + "type": "object", + "properties": { + "title": {"type": "string"}, + "content": {"type": "string"} + } + } + }, + "instruction": "Extract title and main content" + } + }, + "markdown_generator": { + "type": "DefaultMarkdownGenerator", + "params": { + "content_filter": { + "type": "PruningContentFilter", + "params": {"threshold": 0.6} + } + } + } + } + } +} + +response = requests.post("http://localhost:11235/crawl", json=payload) +``` + +### CSS Extraction Strategy + +```python +# CSS-based structured extraction +schema = { + "name": "ProductList", + "baseSelector": ".product", + "fields": [ + {"name": "title", "selector": "h2", "type": "text"}, + {"name": "price", "selector": ".price", "type": "text"}, + {"name": "link", "selector": "a", "type": "attribute", "attribute": "href"} + ] +} + +payload = { + "urls": ["https://example-shop.com"], + "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, + "crawler_config": { + "type": "CrawlerRunConfig", + "params": { + "extraction_strategy": { + "type": "JsonCssExtractionStrategy", + "params": { + "schema": {"type": "dict", "value": schema} + } + } + } + } +} + +response = requests.post("http://localhost:11235/crawl", json=payload) +data = response.json() +extracted = json.loads(data["results"][0]["extracted_content"]) +``` + +### MCP (Model Context Protocol) Integration + +```bash +# Add Crawl4AI as MCP provider to Claude Code +claude mcp add --transport sse c4ai-sse http://localhost:11235/mcp/sse + +# List MCP providers +claude mcp list + +# Test MCP connection +python tests/mcp/test_mcp_socket.py + +# Available MCP endpoints +# SSE: http://localhost:11235/mcp/sse +# WebSocket: ws://localhost:11235/mcp/ws +# Schema: http://localhost:11235/mcp/schema +``` + +Available MCP tools: +- `md` - Generate markdown from web content +- `html` - Extract preprocessed HTML +- `screenshot` - Capture webpage screenshots +- `pdf` - Generate PDF documents +- `execute_js` - Run JavaScript on web pages +- `crawl` - Perform multi-URL crawling +- `ask` - Query Crawl4AI library context + +### Configuration Management + +```yaml +# config.yml structure +app: + title: "Crawl4AI API" + version: "1.0.0" + host: "0.0.0.0" + port: 11235 + timeout_keep_alive: 300 + +llm: + provider: "openai/gpt-4o-mini" + api_key_env: "OPENAI_API_KEY" + +security: + enabled: false + jwt_enabled: false + trusted_hosts: ["*"] + +crawler: + memory_threshold_percent: 95.0 + rate_limiter: + base_delay: [1.0, 2.0] + timeouts: + stream_init: 30.0 + batch_process: 300.0 + pool: + max_pages: 40 + idle_ttl_sec: 1800 + +rate_limiting: + enabled: true + default_limit: "1000/minute" + storage_uri: "memory://" + +logging: + level: "INFO" + format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s" +``` + +### Custom Configuration Deployment + +```bash +# Method 1: Mount custom config +docker run -d -p 11235:11235 \ + --name crawl4ai-custom \ + --env-file .llm.env \ + --shm-size=1g \ + -v $(pwd)/my-config.yml:/app/config.yml \ + unclecode/crawl4ai:latest + +# Method 2: Build with custom config +# Edit deploy/docker/config.yml then build +docker buildx build -t crawl4ai-custom:latest --load . +``` + +### Monitoring and Health Checks + +```bash +# Health endpoint +curl http://localhost:11235/health + +# Prometheus metrics +curl http://localhost:11235/metrics + +# Configuration validation +curl -X POST http://localhost:11235/config/dump \ + -H "Content-Type: application/json" \ + -d '{"code": "CrawlerRunConfig(cache_mode=\"BYPASS\", screenshot=True)"}' +``` + +### Playground Interface + +Access the interactive playground at `http://localhost:11235/playground` for: +- Testing configurations with visual interface +- Generating JSON payloads for REST API +- Converting Python config to JSON format +- Testing crawl operations directly in browser + +### Async Job Processing + +```python +# Submit job for async processing +import time + +# Submit crawl job +response = requests.post("http://localhost:11235/crawl/job", json=payload) +task_id = response.json()["task_id"] + +# Poll for completion +while True: + result = requests.get(f"http://localhost:11235/crawl/job/{task_id}") + status = result.json() + + if status["status"] in ["COMPLETED", "FAILED"]: + break + time.sleep(1.5) + +print("Final result:", status) +``` + +### Production Deployment + +```bash +# Production-ready deployment +docker run -d \ + --name crawl4ai-prod \ + --restart unless-stopped \ + -p 11235:11235 \ + --env-file .llm.env \ + --shm-size=2g \ + --memory=8g \ + --cpus=4 \ + -v /path/to/custom-config.yml:/app/config.yml \ + unclecode/crawl4ai:latest + +# With Docker Compose for production +version: '3.8' +services: + crawl4ai: + image: unclecode/crawl4ai:latest + ports: + - "11235:11235" + environment: + - OPENAI_API_KEY=${OPENAI_API_KEY} + volumes: + - ./config.yml:/app/config.yml + shm_size: 2g + deploy: + resources: + limits: + memory: 8G + cpus: '4' + restart: unless-stopped +``` + +### Configuration Validation and JSON Structure + +```python +# Method 1: Create config objects and dump to see expected JSON structure +from crawl4ai import BrowserConfig, CrawlerRunConfig, LLMConfig, CacheMode +from crawl4ai.extraction_strategy import JsonCssExtractionStrategy, LLMExtractionStrategy +import json + +# Create browser config and see JSON structure +browser_config = BrowserConfig( + headless=True, + viewport_width=1280, + viewport_height=720, + proxy="http://user:pass@proxy:8080" +) + +# Get JSON structure +browser_json = browser_config.dump() +print("BrowserConfig JSON structure:") +print(json.dumps(browser_json, indent=2)) + +# Create crawler config with extraction strategy +schema = { + "name": "Articles", + "baseSelector": ".article", + "fields": [ + {"name": "title", "selector": "h2", "type": "text"}, + {"name": "content", "selector": ".content", "type": "html"} + ] +} + +crawler_config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + screenshot=True, + extraction_strategy=JsonCssExtractionStrategy(schema), + js_code=["window.scrollTo(0, document.body.scrollHeight);"], + wait_for="css:.loaded" +) + +crawler_json = crawler_config.dump() +print("\nCrawlerRunConfig JSON structure:") +print(json.dumps(crawler_json, indent=2)) +``` + +### Reverse Validation - JSON to Objects + +```python +# Method 2: Load JSON back to config objects for validation +from crawl4ai.async_configs import from_serializable_dict + +# Test JSON structure by converting back to objects +test_browser_json = { + "type": "BrowserConfig", + "params": { + "headless": True, + "viewport_width": 1280, + "proxy": "http://user:pass@proxy:8080" + } +} + +try: + # Convert JSON back to object + restored_browser = from_serializable_dict(test_browser_json) + print(f"✅ Valid BrowserConfig: {type(restored_browser)}") + print(f"Headless: {restored_browser.headless}") + print(f"Proxy: {restored_browser.proxy}") +except Exception as e: + print(f"❌ Invalid BrowserConfig JSON: {e}") + +# Test complex crawler config JSON +test_crawler_json = { + "type": "CrawlerRunConfig", + "params": { + "cache_mode": "bypass", + "screenshot": True, + "extraction_strategy": { + "type": "JsonCssExtractionStrategy", + "params": { + "schema": { + "type": "dict", + "value": { + "name": "Products", + "baseSelector": ".product", + "fields": [ + {"name": "title", "selector": "h3", "type": "text"} + ] + } + } + } + } + } +} + +try: + restored_crawler = from_serializable_dict(test_crawler_json) + print(f"✅ Valid CrawlerRunConfig: {type(restored_crawler)}") + print(f"Cache mode: {restored_crawler.cache_mode}") + print(f"Has extraction strategy: {restored_crawler.extraction_strategy is not None}") +except Exception as e: + print(f"❌ Invalid CrawlerRunConfig JSON: {e}") +``` + +### Using Server's /config/dump Endpoint for Validation + +```python +import requests + +# Method 3: Use server endpoint to validate configuration syntax +def validate_config_with_server(config_code: str) -> dict: + """Validate configuration using server's /config/dump endpoint""" + response = requests.post( + "http://localhost:11235/config/dump", + json={"code": config_code} + ) + + if response.status_code == 200: + print("✅ Valid configuration syntax") + return response.json() + else: + print(f"❌ Invalid configuration: {response.status_code}") + print(response.json()) + return None + +# Test valid configuration +valid_config = """ +CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + screenshot=True, + js_code=["window.scrollTo(0, document.body.scrollHeight);"], + wait_for="css:.content-loaded" +) +""" + +result = validate_config_with_server(valid_config) +if result: + print("Generated JSON structure:") + print(json.dumps(result, indent=2)) + +# Test invalid configuration (should fail) +invalid_config = """ +CrawlerRunConfig( + cache_mode="invalid_mode", + screenshot=True, + js_code=some_function() # This will fail +) +""" + +validate_config_with_server(invalid_config) +``` + +### Configuration Builder Helper + +```python +def build_and_validate_request(urls, browser_params=None, crawler_params=None): + """Helper to build and validate complete request payload""" + + # Create configurations + browser_config = BrowserConfig(**(browser_params or {})) + crawler_config = CrawlerRunConfig(**(crawler_params or {})) + + # Build complete request payload + payload = { + "urls": urls if isinstance(urls, list) else [urls], + "browser_config": browser_config.dump(), + "crawler_config": crawler_config.dump() + } + + print("✅ Complete request payload:") + print(json.dumps(payload, indent=2)) + + # Validate by attempting to reconstruct + try: + test_browser = from_serializable_dict(payload["browser_config"]) + test_crawler = from_serializable_dict(payload["crawler_config"]) + print("✅ Payload validation successful") + return payload + except Exception as e: + print(f"❌ Payload validation failed: {e}") + return None + +# Example usage +payload = build_and_validate_request( + urls=["https://example.com"], + browser_params={"headless": True, "viewport_width": 1280}, + crawler_params={ + "cache_mode": CacheMode.BYPASS, + "screenshot": True, + "word_count_threshold": 10 + } +) + +if payload: + # Send to server + response = requests.post("http://localhost:11235/crawl", json=payload) + print(f"Server response: {response.status_code}") +``` + +### Common JSON Structure Patterns + +```python +# Pattern 1: Simple primitive values +simple_config = { + "type": "CrawlerRunConfig", + "params": { + "cache_mode": "bypass", # String enum value + "screenshot": True, # Boolean + "page_timeout": 60000 # Integer + } +} + +# Pattern 2: Nested objects +nested_config = { + "type": "CrawlerRunConfig", + "params": { + "extraction_strategy": { + "type": "LLMExtractionStrategy", + "params": { + "llm_config": { + "type": "LLMConfig", + "params": { + "provider": "openai/gpt-4o-mini", + "api_token": "env:OPENAI_API_KEY" + } + }, + "instruction": "Extract main content" + } + } + } +} + +# Pattern 3: Dictionary values (must use type: dict wrapper) +dict_config = { + "type": "CrawlerRunConfig", + "params": { + "extraction_strategy": { + "type": "JsonCssExtractionStrategy", + "params": { + "schema": { + "type": "dict", # Required wrapper + "value": { # Actual dictionary content + "name": "Products", + "baseSelector": ".product", + "fields": [ + {"name": "title", "selector": "h2", "type": "text"} + ] + } + } + } + } + } +} + +# Pattern 4: Lists and arrays +list_config = { + "type": "CrawlerRunConfig", + "params": { + "js_code": [ # Lists are handled directly + "window.scrollTo(0, document.body.scrollHeight);", + "document.querySelector('.load-more')?.click();" + ], + "excluded_tags": ["script", "style", "nav"] + } +} +``` + +### Troubleshooting Common JSON Errors + +```python +def diagnose_json_errors(): + """Common JSON structure errors and fixes""" + + # ❌ WRONG: Missing type wrapper for objects + wrong_config = { + "browser_config": { + "headless": True # Missing type wrapper + } + } + + # ✅ CORRECT: Proper type wrapper + correct_config = { + "browser_config": { + "type": "BrowserConfig", + "params": { + "headless": True + } + } + } + + # ❌ WRONG: Dictionary without type: dict wrapper + wrong_dict = { + "schema": { + "name": "Products" # Raw dict, should be wrapped + } + } + + # ✅ CORRECT: Dictionary with proper wrapper + correct_dict = { + "schema": { + "type": "dict", + "value": { + "name": "Products" + } + } + } + + # ❌ WRONG: Invalid enum string + wrong_enum = { + "cache_mode": "DISABLED" # Wrong case/value + } + + # ✅ CORRECT: Valid enum string + correct_enum = { + "cache_mode": "bypass" # or "enabled", "disabled", etc. + } + + print("Common error patterns documented above") + +# Validate your JSON structure before sending +def pre_flight_check(payload): + """Run checks before sending to server""" + required_keys = ["urls", "browser_config", "crawler_config"] + + for key in required_keys: + if key not in payload: + print(f"❌ Missing required key: {key}") + return False + + # Check type wrappers + for config_key in ["browser_config", "crawler_config"]: + config = payload[config_key] + if not isinstance(config, dict) or "type" not in config: + print(f"❌ {config_key} missing type wrapper") + return False + if "params" not in config: + print(f"❌ {config_key} missing params") + return False + + print("✅ Pre-flight check passed") + return True + +# Example usage +payload = { + "urls": ["https://example.com"], + "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, + "crawler_config": {"type": "CrawlerRunConfig", "params": {"cache_mode": "bypass"}} +} + +if pre_flight_check(payload): + # Safe to send to server + pass +``` + +**📖 Learn more:** [Complete Docker Guide](https://docs.crawl4ai.com/core/docker-deployment/), [API Reference](https://docs.crawl4ai.com/api/), [MCP Integration](https://docs.crawl4ai.com/core/docker-deployment/#mcp-model-context-protocol-support), [Configuration Options](https://docs.crawl4ai.com/core/docker-deployment/#server-configuration) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/extraction.txt b/docs/md_v2/assets/llm.txt/txt/extraction.txt new file mode 100644 index 00000000..fa56dbe8 --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/extraction.txt @@ -0,0 +1,788 @@ +## Extraction Strategies + +Powerful data extraction from web pages using LLM-based intelligent parsing or fast schema/pattern-based approaches. + +### LLM-Based Extraction - Intelligent Content Understanding + +```python +import os +import asyncio +import json +from pydantic import BaseModel, Field +from typing import List +from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, LLMConfig +from crawl4ai.extraction_strategy import LLMExtractionStrategy + +# Define structured data model +class Product(BaseModel): + name: str = Field(description="Product name") + price: str = Field(description="Product price") + description: str = Field(description="Product description") + features: List[str] = Field(description="List of product features") + rating: float = Field(description="Product rating out of 5") + +# Configure LLM provider +llm_config = LLMConfig( + provider="openai/gpt-4o-mini", # or "ollama/llama3.3", "anthropic/claude-3-5-sonnet" + api_token=os.getenv("OPENAI_API_KEY"), # or "env:OPENAI_API_KEY" + temperature=0.1, + max_tokens=2000 +) + +# Create LLM extraction strategy +llm_strategy = LLMExtractionStrategy( + llm_config=llm_config, + schema=Product.model_json_schema(), + extraction_type="schema", # or "block" for freeform text + instruction=""" + Extract product information from the webpage content. + Focus on finding complete product details including: + - Product name and price + - Detailed description + - All listed features + - Customer rating if available + Return valid JSON array of products. + """, + chunk_token_threshold=1200, # Split content if too large + overlap_rate=0.1, # 10% overlap between chunks + apply_chunking=True, # Enable automatic chunking + input_format="markdown", # "html", "fit_markdown", or "markdown" + extra_args={"temperature": 0.0, "max_tokens": 800}, + verbose=True +) + +async def extract_with_llm(): + browser_config = BrowserConfig(headless=True) + + crawl_config = CrawlerRunConfig( + extraction_strategy=llm_strategy, + cache_mode=CacheMode.BYPASS, + word_count_threshold=10 + ) + + async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun( + url="https://example.com/products", + config=crawl_config + ) + + if result.success: + # Parse extracted JSON + products = json.loads(result.extracted_content) + print(f"Extracted {len(products)} products") + + for product in products[:3]: # Show first 3 + print(f"Product: {product['name']}") + print(f"Price: {product['price']}") + print(f"Rating: {product.get('rating', 'N/A')}") + + # Show token usage and cost + llm_strategy.show_usage() + else: + print(f"Extraction failed: {result.error_message}") + +asyncio.run(extract_with_llm()) +``` + +### LLM Strategy Advanced Configuration + +```python +# Multiple provider configurations +providers = { + "openai": LLMConfig( + provider="openai/gpt-4o", + api_token="env:OPENAI_API_KEY", + temperature=0.1 + ), + "anthropic": LLMConfig( + provider="anthropic/claude-3-5-sonnet-20240620", + api_token="env:ANTHROPIC_API_KEY", + max_tokens=4000 + ), + "ollama": LLMConfig( + provider="ollama/llama3.3", + api_token=None, # Not needed for Ollama + base_url="http://localhost:11434" + ), + "groq": LLMConfig( + provider="groq/llama3-70b-8192", + api_token="env:GROQ_API_KEY" + ) +} + +# Advanced chunking for large content +large_content_strategy = LLMExtractionStrategy( + llm_config=providers["openai"], + schema=YourModel.model_json_schema(), + extraction_type="schema", + instruction="Extract detailed information...", + + # Chunking parameters + chunk_token_threshold=2000, # Larger chunks for complex content + overlap_rate=0.15, # More overlap for context preservation + apply_chunking=True, + + # Input format selection + input_format="fit_markdown", # Use filtered content if available + + # LLM parameters + extra_args={ + "temperature": 0.0, # Deterministic output + "top_p": 0.9, + "frequency_penalty": 0.1, + "presence_penalty": 0.1, + "max_tokens": 1500 + }, + verbose=True +) + +# Knowledge graph extraction +class Entity(BaseModel): + name: str + type: str # "person", "organization", "location", etc. + description: str + +class Relationship(BaseModel): + source: str + target: str + relationship: str + confidence: float + +class KnowledgeGraph(BaseModel): + entities: List[Entity] + relationships: List[Relationship] + summary: str + +knowledge_strategy = LLMExtractionStrategy( + llm_config=providers["anthropic"], + schema=KnowledgeGraph.model_json_schema(), + extraction_type="schema", + instruction=""" + Create a knowledge graph from the content by: + 1. Identifying key entities (people, organizations, locations, concepts) + 2. Finding relationships between entities + 3. Providing confidence scores for relationships + 4. Summarizing the main topics + """, + input_format="html", # Use HTML for better structure preservation + apply_chunking=True, + chunk_token_threshold=1500 +) +``` + +### JSON CSS Extraction - Fast Schema-Based Extraction + +```python +import asyncio +import json +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode +from crawl4ai.extraction_strategy import JsonCssExtractionStrategy + +# Basic CSS extraction schema +simple_schema = { + "name": "Product Listings", + "baseSelector": "div.product-card", + "fields": [ + { + "name": "title", + "selector": "h2.product-title", + "type": "text" + }, + { + "name": "price", + "selector": ".price", + "type": "text" + }, + { + "name": "image_url", + "selector": "img.product-image", + "type": "attribute", + "attribute": "src" + }, + { + "name": "product_url", + "selector": "a.product-link", + "type": "attribute", + "attribute": "href" + } + ] +} + +# Complex nested schema with multiple data types +complex_schema = { + "name": "E-commerce Product Catalog", + "baseSelector": "div.category", + "baseFields": [ + { + "name": "category_id", + "type": "attribute", + "attribute": "data-category-id" + }, + { + "name": "category_url", + "type": "attribute", + "attribute": "data-url" + } + ], + "fields": [ + { + "name": "category_name", + "selector": "h2.category-title", + "type": "text" + }, + { + "name": "products", + "selector": "div.product", + "type": "nested_list", # Array of complex objects + "fields": [ + { + "name": "name", + "selector": "h3.product-name", + "type": "text", + "default": "Unknown Product" + }, + { + "name": "price", + "selector": "span.price", + "type": "text" + }, + { + "name": "details", + "selector": "div.product-details", + "type": "nested", # Single complex object + "fields": [ + { + "name": "brand", + "selector": "span.brand", + "type": "text" + }, + { + "name": "model", + "selector": "span.model", + "type": "text" + }, + { + "name": "specs", + "selector": "div.specifications", + "type": "html" # Preserve HTML structure + } + ] + }, + { + "name": "features", + "selector": "ul.features li", + "type": "list", # Simple array of strings + "fields": [ + {"name": "feature", "type": "text"} + ] + }, + { + "name": "reviews", + "selector": "div.review", + "type": "nested_list", + "fields": [ + { + "name": "reviewer", + "selector": "span.reviewer-name", + "type": "text" + }, + { + "name": "rating", + "selector": "span.rating", + "type": "attribute", + "attribute": "data-rating" + }, + { + "name": "comment", + "selector": "p.review-text", + "type": "text" + }, + { + "name": "date", + "selector": "time.review-date", + "type": "attribute", + "attribute": "datetime" + } + ] + } + ] + } + ] +} + +async def extract_with_css_schema(): + strategy = JsonCssExtractionStrategy(complex_schema, verbose=True) + + config = CrawlerRunConfig( + extraction_strategy=strategy, + cache_mode=CacheMode.BYPASS, + # Enable dynamic content loading if needed + js_code="window.scrollTo(0, document.body.scrollHeight);", + wait_for="css:.product:nth-child(10)", # Wait for products to load + process_iframes=True + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun( + url="https://example.com/catalog", + config=config + ) + + if result.success: + data = json.loads(result.extracted_content) + print(f"Extracted {len(data)} categories") + + for category in data: + print(f"Category: {category['category_name']}") + print(f"Products: {len(category.get('products', []))}") + + # Show first product details + if category.get('products'): + product = category['products'][0] + print(f" First product: {product.get('name')}") + print(f" Features: {len(product.get('features', []))}") + print(f" Reviews: {len(product.get('reviews', []))}") + +asyncio.run(extract_with_css_schema()) +``` + +### Automatic Schema Generation - One-Time LLM, Unlimited Use + +```python +import json +import asyncio +from pathlib import Path +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, LLMConfig +from crawl4ai.extraction_strategy import JsonCssExtractionStrategy + +async def generate_and_use_schema(): + """ + 1. Use LLM once to generate schema from sample HTML + 2. Cache the schema for reuse + 3. Use cached schema for fast extraction without LLM calls + """ + + cache_dir = Path("./schema_cache") + cache_dir.mkdir(exist_ok=True) + schema_file = cache_dir / "ecommerce_schema.json" + + # Step 1: Generate or load cached schema + if schema_file.exists(): + schema = json.load(schema_file.open()) + print("Using cached schema") + else: + print("Generating schema using LLM...") + + # Configure LLM for schema generation + llm_config = LLMConfig( + provider="openai/gpt-4o", # or "ollama/llama3.3" for local + api_token="env:OPENAI_API_KEY" + ) + + # Get sample HTML from target site + async with AsyncWebCrawler() as crawler: + sample_result = await crawler.arun( + url="https://example.com/products", + config=CrawlerRunConfig(cache_mode=CacheMode.BYPASS) + ) + sample_html = sample_result.cleaned_html[:5000] # Use first 5k chars + + # Generate schema automatically (ONE-TIME LLM COST) + schema = JsonCssExtractionStrategy.generate_schema( + html=sample_html, + schema_type="css", + llm_config=llm_config, + instruction="Extract product information including name, price, description, and features" + ) + + # Cache schema for future use (NO MORE LLM CALLS) + json.dump(schema, schema_file.open("w"), indent=2) + print("Schema generated and cached") + + # Step 2: Use schema for fast extraction (NO LLM CALLS) + strategy = JsonCssExtractionStrategy(schema, verbose=True) + + config = CrawlerRunConfig( + extraction_strategy=strategy, + cache_mode=CacheMode.BYPASS + ) + + # Step 3: Extract from multiple pages using same schema + urls = [ + "https://example.com/products", + "https://example.com/electronics", + "https://example.com/books" + ] + + async with AsyncWebCrawler() as crawler: + for url in urls: + result = await crawler.arun(url=url, config=config) + + if result.success: + data = json.loads(result.extracted_content) + print(f"{url}: Extracted {len(data)} items") + else: + print(f"{url}: Failed - {result.error_message}") + +asyncio.run(generate_and_use_schema()) +``` + +### XPath Extraction Strategy + +```python +from crawl4ai.extraction_strategy import JsonXPathExtractionStrategy + +# XPath-based schema (alternative to CSS) +xpath_schema = { + "name": "News Articles", + "baseSelector": "//article[@class='news-item']", + "baseFields": [ + { + "name": "article_id", + "type": "attribute", + "attribute": "data-id" + } + ], + "fields": [ + { + "name": "headline", + "selector": ".//h2[@class='headline']", + "type": "text" + }, + { + "name": "author", + "selector": ".//span[@class='author']/text()", + "type": "text" + }, + { + "name": "publish_date", + "selector": ".//time/@datetime", + "type": "text" + }, + { + "name": "content", + "selector": ".//div[@class='article-body']", + "type": "html" + }, + { + "name": "tags", + "selector": ".//div[@class='tags']/span[@class='tag']", + "type": "list", + "fields": [ + {"name": "tag", "type": "text"} + ] + } + ] +} + +# Generate XPath schema automatically +async def generate_xpath_schema(): + llm_config = LLMConfig(provider="ollama/llama3.3", api_token=None) + + sample_html = """ +Content here...
Content
" + result = await strategy.crawl(raw_html) + print(f"Raw content: {result.html}") + + # Raw content with complex HTML + complex_html = """raw:// + +Paragraph content
+Content
" +result = await crawler.arun(f"raw://{raw_html}") + +# Crawl local file +result = await crawler.arun("file:///path/to/local/file.html") + +# Both return standard CrawlResult objects +print(result.markdown) +``` + +## Table Extraction + +Extract structured data from HTML tables with automatic detection and scoring. + +### Basic Table Extraction + +```python +import asyncio +import pandas as pd +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode + +async def extract_tables(): + async with AsyncWebCrawler() as crawler: + config = CrawlerRunConfig( + table_score_threshold=7, # Higher = stricter detection + cache_mode=CacheMode.BYPASS + ) + + result = await crawler.arun("https://example.com/tables", config=config) + + if result.success and result.tables: + # New tables field (v0.6+) + for i, table in enumerate(result.tables): + print(f"Table {i+1}:") + print(f"Headers: {table['headers']}") + print(f"Rows: {len(table['rows'])}") + print(f"Caption: {table.get('caption', 'No caption')}") + + # Convert to DataFrame + df = pd.DataFrame(table['rows'], columns=table['headers']) + print(df.head()) + +asyncio.run(extract_tables()) +``` + +### Advanced Table Processing + +```python +from crawl4ai import LXMLWebScrapingStrategy + +async def process_financial_tables(): + config = CrawlerRunConfig( + table_score_threshold=8, # Strict detection for data tables + scraping_strategy=LXMLWebScrapingStrategy(), + keep_data_attributes=True, + scan_full_page=True + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://coinmarketcap.com", config=config) + + if result.tables: + # Get the main data table (usually first/largest) + main_table = result.tables[0] + + # Create DataFrame + df = pd.DataFrame( + main_table['rows'], + columns=main_table['headers'] + ) + + # Clean and process data + df = clean_financial_data(df) + + # Save for analysis + df.to_csv("market_data.csv", index=False) + return df + +def clean_financial_data(df): + """Clean currency symbols, percentages, and large numbers""" + for col in df.columns: + if 'price' in col.lower(): + # Remove currency symbols + df[col] = df[col].str.replace(r'[^\d.]', '', regex=True) + df[col] = pd.to_numeric(df[col], errors='coerce') + + elif '%' in str(df[col].iloc[0]): + # Convert percentages + df[col] = df[col].str.replace('%', '').astype(float) / 100 + + elif any(suffix in str(df[col].iloc[0]) for suffix in ['B', 'M', 'K']): + # Handle large numbers (Billions, Millions, etc.) + df[col] = df[col].apply(convert_large_numbers) + + return df + +def convert_large_numbers(value): + """Convert 1.5B -> 1500000000""" + if pd.isna(value): + return float('nan') + + value = str(value) + multiplier = 1 + if 'B' in value: + multiplier = 1e9 + elif 'M' in value: + multiplier = 1e6 + elif 'K' in value: + multiplier = 1e3 + + number = float(re.sub(r'[^\d.]', '', value)) + return number * multiplier +``` + +### Table Detection Configuration + +```python +# Strict table detection (data-heavy pages) +strict_config = CrawlerRunConfig( + table_score_threshold=9, # Only high-quality tables + word_count_threshold=5, # Ignore sparse content + excluded_tags=['nav', 'footer'] # Skip navigation tables +) + +# Lenient detection (mixed content pages) +lenient_config = CrawlerRunConfig( + table_score_threshold=5, # Include layout tables + process_iframes=True, # Check embedded tables + scan_full_page=True # Scroll to load dynamic tables +) + +# Financial/data site optimization +financial_config = CrawlerRunConfig( + table_score_threshold=8, + scraping_strategy=LXMLWebScrapingStrategy(), + wait_for="css:table", # Wait for tables to load + scan_full_page=True, + scroll_delay=0.2 +) +``` + +### Multi-Table Processing + +```python +async def extract_all_tables(): + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://example.com/data", config=config) + + tables_data = {} + + for i, table in enumerate(result.tables): + # Create meaningful names based on content + table_name = ( + table.get('caption') or + f"table_{i+1}_{table['headers'][0]}" + ).replace(' ', '_').lower() + + df = pd.DataFrame(table['rows'], columns=table['headers']) + + # Store with metadata + tables_data[table_name] = { + 'dataframe': df, + 'headers': table['headers'], + 'row_count': len(table['rows']), + 'caption': table.get('caption'), + 'summary': table.get('summary') + } + + return tables_data + +# Usage +tables = await extract_all_tables() +for name, data in tables.items(): + print(f"{name}: {data['row_count']} rows") + data['dataframe'].to_csv(f"{name}.csv") +``` + +### Backward Compatibility + +```python +# Support both new and old table formats +def get_tables(result): + # New format (v0.6+) + if hasattr(result, 'tables') and result.tables: + return result.tables + + # Fallback to media.tables (older versions) + return result.media.get('tables', []) + +# Usage in existing code +result = await crawler.arun(url, config=config) +tables = get_tables(result) + +for table in tables: + df = pd.DataFrame(table['rows'], columns=table['headers']) + # Process table data... +``` + +### Table Quality Scoring + +```python +# Understanding table_score_threshold values: +# 10: Only perfect data tables (headers + data rows) +# 8-9: High-quality tables (recommended for financial/data sites) +# 6-7: Mixed content tables (news sites, wikis) +# 4-5: Layout tables included (broader detection) +# 1-3: All table-like structures (very permissive) + +config = CrawlerRunConfig( + table_score_threshold=8, # Balanced detection + verbose=True # See scoring details in logs +) +``` + + +**📖 Learn more:** [CrawlResult API Reference](https://docs.crawl4ai.com/api/crawl-result/), [Browser & Crawler Configuration](https://docs.crawl4ai.com/core/browser-crawler-config/), [Cache Modes](https://docs.crawl4ai.com/core/cache-modes/) +--- + + +## Browser, Crawler & LLM Configuration + +Core configuration classes for controlling browser behavior, crawl operations, LLM providers, and understanding crawl results. + +### BrowserConfig - Browser Environment Setup + +```python +from crawl4ai import BrowserConfig, AsyncWebCrawler + +# Basic browser configuration +browser_config = BrowserConfig( + browser_type="chromium", # "chromium", "firefox", "webkit" + headless=True, # False for visible browser (debugging) + viewport_width=1280, + viewport_height=720, + verbose=True +) + +# Advanced browser setup with proxy and persistence +browser_config = BrowserConfig( + headless=False, + proxy="http://user:pass@proxy:8080", + use_persistent_context=True, + user_data_dir="./browser_data", + cookies=[ + {"name": "session", "value": "abc123", "domain": "example.com"} + ], + headers={"Accept-Language": "en-US,en;q=0.9"}, + user_agent="Mozilla/5.0 (X11; Linux x86_64) Chrome/116.0.0.0 Safari/537.36", + text_mode=True, # Disable images for faster crawling + extra_args=["--disable-extensions", "--no-sandbox"] +) + +async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun("https://example.com") +``` + +### CrawlerRunConfig - Crawl Operation Control + +```python +from crawl4ai import CrawlerRunConfig, CacheMode +from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator +from crawl4ai.content_filter_strategy import PruningContentFilter + +# Basic crawl configuration +run_config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + word_count_threshold=10, + excluded_tags=["nav", "footer", "script"], + exclude_external_links=True, + screenshot=True, + pdf=True +) + +# Advanced content processing +md_generator = DefaultMarkdownGenerator( + content_filter=PruningContentFilter(threshold=0.6), + options={"citations": True, "ignore_links": False} +) + +run_config = CrawlerRunConfig( + # Content processing + markdown_generator=md_generator, + css_selector="main.content", # Focus on specific content + target_elements=[".article", ".post"], # Multiple target selectors + process_iframes=True, + remove_overlay_elements=True, + + # Page interaction + js_code=[ + "window.scrollTo(0, document.body.scrollHeight);", + "document.querySelector('.load-more')?.click();" + ], + wait_for="css:.content-loaded", + wait_for_timeout=10000, + scan_full_page=True, + + # Session management + session_id="persistent_session", + + # Media handling + screenshot=True, + pdf=True, + capture_mhtml=True, + image_score_threshold=5, + + # Advanced options + simulate_user=True, + magic=True, # Auto-handle popups + verbose=True +) +``` + +### CrawlerRunConfig Parameters by Category + +```python +# Content Processing +config = CrawlerRunConfig( + word_count_threshold=10, # Min words per content block + css_selector="main.article", # Focus on specific content + target_elements=[".post", ".content"], # Multiple target selectors + excluded_tags=["nav", "footer"], # Remove these tags + excluded_selector="#ads, .tracker", # Remove by selector + only_text=True, # Text-only extraction + keep_data_attributes=True, # Preserve data-* attributes + remove_forms=True, # Remove all forms + process_iframes=True # Include iframe content +) + +# Page Navigation & Timing +config = CrawlerRunConfig( + wait_until="networkidle", # Wait condition + page_timeout=60000, # 60 second timeout + wait_for="css:.loaded", # Wait for specific element + wait_for_images=True, # Wait for images to load + delay_before_return_html=0.5, # Final delay before capture + semaphore_count=10 # Max concurrent operations +) + +# Page Interaction +config = CrawlerRunConfig( + js_code="document.querySelector('button').click();", + scan_full_page=True, # Auto-scroll page + scroll_delay=0.3, # Delay between scrolls + remove_overlay_elements=True, # Remove popups/modals + simulate_user=True, # Simulate human behavior + override_navigator=True, # Override navigator properties + magic=True # Auto-handle common patterns +) + +# Caching & Session +config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, # Cache behavior + session_id="my_session", # Persistent session + shared_data={"context": "value"} # Share data between hooks +) + +# Media & Output +config = CrawlerRunConfig( + screenshot=True, # Capture screenshot + pdf=True, # Generate PDF + capture_mhtml=True, # Capture MHTML archive + image_score_threshold=3, # Filter low-quality images + exclude_external_images=True # Remove external images +) + +# Link & Domain Filtering +config = CrawlerRunConfig( + exclude_external_links=True, # Remove external links + exclude_social_media_links=True, # Remove social media links + exclude_domains=["ads.com", "tracker.io"], # Custom domain filter + exclude_internal_links=False # Keep internal links +) +``` + +### LLMConfig - Language Model Setup + +```python +from crawl4ai import LLMConfig + +# OpenAI configuration +llm_config = LLMConfig( + provider="openai/gpt-4o-mini", + api_token=os.getenv("OPENAI_API_KEY"), # or "env:OPENAI_API_KEY" + temperature=0.1, + max_tokens=2000 +) + +# Local model with Ollama +llm_config = LLMConfig( + provider="ollama/llama3.3", + api_token=None, # Not needed for Ollama + base_url="http://localhost:11434" # Custom endpoint +) + +# Anthropic Claude +llm_config = LLMConfig( + provider="anthropic/claude-3-5-sonnet-20240620", + api_token="env:ANTHROPIC_API_KEY", + max_tokens=4000 +) + +# Google Gemini +llm_config = LLMConfig( + provider="gemini/gemini-1.5-pro", + api_token="env:GEMINI_API_KEY" +) + +# Groq (fast inference) +llm_config = LLMConfig( + provider="groq/llama3-70b-8192", + api_token="env:GROQ_API_KEY" +) +``` + +### CrawlResult - Understanding Output + +```python +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig + +async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://example.com", config=run_config) + + # Basic status information + print(f"Success: {result.success}") + print(f"Status: {result.status_code}") + print(f"URL: {result.url}") + + if not result.success: + print(f"Error: {result.error_message}") + return + + # HTML content variants + print(f"Original HTML: {len(result.html)} chars") + print(f"Cleaned HTML: {len(result.cleaned_html or '')} chars") + + # Markdown output (MarkdownGenerationResult) + if result.markdown: + print(f"Raw markdown: {len(result.markdown.raw_markdown)} chars") + print(f"With citations: {len(result.markdown.markdown_with_citations)} chars") + + # Filtered content (if content filter was used) + if result.markdown.fit_markdown: + print(f"Fit markdown: {len(result.markdown.fit_markdown)} chars") + print(f"Fit HTML: {len(result.markdown.fit_html)} chars") + + # Extracted structured data + if result.extracted_content: + import json + data = json.loads(result.extracted_content) + print(f"Extracted {len(data)} items") + + # Media and links + images = result.media.get("images", []) + print(f"Found {len(images)} images") + for img in images[:3]: # First 3 images + print(f" {img.get('src')} (score: {img.get('score', 0)})") + + internal_links = result.links.get("internal", []) + external_links = result.links.get("external", []) + print(f"Links: {len(internal_links)} internal, {len(external_links)} external") + + # Generated files + if result.screenshot: + print(f"Screenshot captured: {len(result.screenshot)} chars (base64)") + # Save screenshot + import base64 + with open("page.png", "wb") as f: + f.write(base64.b64decode(result.screenshot)) + + if result.pdf: + print(f"PDF generated: {len(result.pdf)} bytes") + with open("page.pdf", "wb") as f: + f.write(result.pdf) + + if result.mhtml: + print(f"MHTML captured: {len(result.mhtml)} chars") + with open("page.mhtml", "w", encoding="utf-8") as f: + f.write(result.mhtml) + + # SSL certificate information + if result.ssl_certificate: + print(f"SSL Issuer: {result.ssl_certificate.issuer}") + print(f"Valid until: {result.ssl_certificate.valid_until}") + + # Network and console data (if captured) + if result.network_requests: + requests = [r for r in result.network_requests if r.get("event_type") == "request"] + print(f"Network requests captured: {len(requests)}") + + if result.console_messages: + errors = [m for m in result.console_messages if m.get("type") == "error"] + print(f"Console messages: {len(result.console_messages)} ({len(errors)} errors)") + + # Session and metadata + if result.session_id: + print(f"Session ID: {result.session_id}") + + if result.metadata: + print(f"Metadata: {result.metadata.get('title', 'No title')}") +``` + +### Configuration Helpers and Best Practices + +```python +# Clone configurations for variations +base_config = CrawlerRunConfig( + cache_mode=CacheMode.ENABLED, + word_count_threshold=200, + verbose=True +) + +# Create streaming version +stream_config = base_config.clone( + stream=True, + cache_mode=CacheMode.BYPASS +) + +# Create debug version +debug_config = base_config.clone( + headless=False, + page_timeout=120000, + verbose=True +) + +# Serialize/deserialize configurations +config_dict = base_config.dump() # Convert to dict +restored_config = CrawlerRunConfig.load(config_dict) # Restore from dict + +# Browser configuration management +browser_config = BrowserConfig(headless=True, text_mode=True) +browser_dict = browser_config.to_dict() +cloned_browser = browser_config.clone(headless=False, verbose=True) +``` + +### Common Configuration Patterns + +```python +# Fast text-only crawling +fast_config = CrawlerRunConfig( + cache_mode=CacheMode.ENABLED, + text_mode=True, + exclude_external_links=True, + exclude_external_images=True, + word_count_threshold=50 +) + +# Comprehensive data extraction +comprehensive_config = CrawlerRunConfig( + process_iframes=True, + scan_full_page=True, + wait_for_images=True, + screenshot=True, + capture_network_requests=True, + capture_console_messages=True, + magic=True +) + +# Stealth crawling +stealth_config = CrawlerRunConfig( + simulate_user=True, + override_navigator=True, + mean_delay=2.0, + max_range=1.0, + user_agent_mode="random" +) +``` + +**📖 Learn more:** [Complete Parameter Reference](https://docs.crawl4ai.com/api/parameters/), [Content Filtering](https://docs.crawl4ai.com/core/markdown-generation/), [Session Management](https://docs.crawl4ai.com/advanced/session-management/), [Network Capture](https://docs.crawl4ai.com/advanced/network-console-capture/) +--- + + +## Extraction Strategies + +Powerful data extraction from web pages using LLM-based intelligent parsing or fast schema/pattern-based approaches. + +### LLM-Based Extraction - Intelligent Content Understanding + +```python +import os +import asyncio +import json +from pydantic import BaseModel, Field +from typing import List +from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, LLMConfig +from crawl4ai.extraction_strategy import LLMExtractionStrategy + +# Define structured data model +class Product(BaseModel): + name: str = Field(description="Product name") + price: str = Field(description="Product price") + description: str = Field(description="Product description") + features: List[str] = Field(description="List of product features") + rating: float = Field(description="Product rating out of 5") + +# Configure LLM provider +llm_config = LLMConfig( + provider="openai/gpt-4o-mini", # or "ollama/llama3.3", "anthropic/claude-3-5-sonnet" + api_token=os.getenv("OPENAI_API_KEY"), # or "env:OPENAI_API_KEY" + temperature=0.1, + max_tokens=2000 +) + +# Create LLM extraction strategy +llm_strategy = LLMExtractionStrategy( + llm_config=llm_config, + schema=Product.model_json_schema(), + extraction_type="schema", # or "block" for freeform text + instruction=""" + Extract product information from the webpage content. + Focus on finding complete product details including: + - Product name and price + - Detailed description + - All listed features + - Customer rating if available + Return valid JSON array of products. + """, + chunk_token_threshold=1200, # Split content if too large + overlap_rate=0.1, # 10% overlap between chunks + apply_chunking=True, # Enable automatic chunking + input_format="markdown", # "html", "fit_markdown", or "markdown" + extra_args={"temperature": 0.0, "max_tokens": 800}, + verbose=True +) + +async def extract_with_llm(): + browser_config = BrowserConfig(headless=True) + + crawl_config = CrawlerRunConfig( + extraction_strategy=llm_strategy, + cache_mode=CacheMode.BYPASS, + word_count_threshold=10 + ) + + async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun( + url="https://example.com/products", + config=crawl_config + ) + + if result.success: + # Parse extracted JSON + products = json.loads(result.extracted_content) + print(f"Extracted {len(products)} products") + + for product in products[:3]: # Show first 3 + print(f"Product: {product['name']}") + print(f"Price: {product['price']}") + print(f"Rating: {product.get('rating', 'N/A')}") + + # Show token usage and cost + llm_strategy.show_usage() + else: + print(f"Extraction failed: {result.error_message}") + +asyncio.run(extract_with_llm()) +``` + +### LLM Strategy Advanced Configuration + +```python +# Multiple provider configurations +providers = { + "openai": LLMConfig( + provider="openai/gpt-4o", + api_token="env:OPENAI_API_KEY", + temperature=0.1 + ), + "anthropic": LLMConfig( + provider="anthropic/claude-3-5-sonnet-20240620", + api_token="env:ANTHROPIC_API_KEY", + max_tokens=4000 + ), + "ollama": LLMConfig( + provider="ollama/llama3.3", + api_token=None, # Not needed for Ollama + base_url="http://localhost:11434" + ), + "groq": LLMConfig( + provider="groq/llama3-70b-8192", + api_token="env:GROQ_API_KEY" + ) +} + +# Advanced chunking for large content +large_content_strategy = LLMExtractionStrategy( + llm_config=providers["openai"], + schema=YourModel.model_json_schema(), + extraction_type="schema", + instruction="Extract detailed information...", + + # Chunking parameters + chunk_token_threshold=2000, # Larger chunks for complex content + overlap_rate=0.15, # More overlap for context preservation + apply_chunking=True, + + # Input format selection + input_format="fit_markdown", # Use filtered content if available + + # LLM parameters + extra_args={ + "temperature": 0.0, # Deterministic output + "top_p": 0.9, + "frequency_penalty": 0.1, + "presence_penalty": 0.1, + "max_tokens": 1500 + }, + verbose=True +) + +# Knowledge graph extraction +class Entity(BaseModel): + name: str + type: str # "person", "organization", "location", etc. + description: str + +class Relationship(BaseModel): + source: str + target: str + relationship: str + confidence: float + +class KnowledgeGraph(BaseModel): + entities: List[Entity] + relationships: List[Relationship] + summary: str + +knowledge_strategy = LLMExtractionStrategy( + llm_config=providers["anthropic"], + schema=KnowledgeGraph.model_json_schema(), + extraction_type="schema", + instruction=""" + Create a knowledge graph from the content by: + 1. Identifying key entities (people, organizations, locations, concepts) + 2. Finding relationships between entities + 3. Providing confidence scores for relationships + 4. Summarizing the main topics + """, + input_format="html", # Use HTML for better structure preservation + apply_chunking=True, + chunk_token_threshold=1500 +) +``` + +### JSON CSS Extraction - Fast Schema-Based Extraction + +```python +import asyncio +import json +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode +from crawl4ai.extraction_strategy import JsonCssExtractionStrategy + +# Basic CSS extraction schema +simple_schema = { + "name": "Product Listings", + "baseSelector": "div.product-card", + "fields": [ + { + "name": "title", + "selector": "h2.product-title", + "type": "text" + }, + { + "name": "price", + "selector": ".price", + "type": "text" + }, + { + "name": "image_url", + "selector": "img.product-image", + "type": "attribute", + "attribute": "src" + }, + { + "name": "product_url", + "selector": "a.product-link", + "type": "attribute", + "attribute": "href" + } + ] +} + +# Complex nested schema with multiple data types +complex_schema = { + "name": "E-commerce Product Catalog", + "baseSelector": "div.category", + "baseFields": [ + { + "name": "category_id", + "type": "attribute", + "attribute": "data-category-id" + }, + { + "name": "category_url", + "type": "attribute", + "attribute": "data-url" + } + ], + "fields": [ + { + "name": "category_name", + "selector": "h2.category-title", + "type": "text" + }, + { + "name": "products", + "selector": "div.product", + "type": "nested_list", # Array of complex objects + "fields": [ + { + "name": "name", + "selector": "h3.product-name", + "type": "text", + "default": "Unknown Product" + }, + { + "name": "price", + "selector": "span.price", + "type": "text" + }, + { + "name": "details", + "selector": "div.product-details", + "type": "nested", # Single complex object + "fields": [ + { + "name": "brand", + "selector": "span.brand", + "type": "text" + }, + { + "name": "model", + "selector": "span.model", + "type": "text" + }, + { + "name": "specs", + "selector": "div.specifications", + "type": "html" # Preserve HTML structure + } + ] + }, + { + "name": "features", + "selector": "ul.features li", + "type": "list", # Simple array of strings + "fields": [ + {"name": "feature", "type": "text"} + ] + }, + { + "name": "reviews", + "selector": "div.review", + "type": "nested_list", + "fields": [ + { + "name": "reviewer", + "selector": "span.reviewer-name", + "type": "text" + }, + { + "name": "rating", + "selector": "span.rating", + "type": "attribute", + "attribute": "data-rating" + }, + { + "name": "comment", + "selector": "p.review-text", + "type": "text" + }, + { + "name": "date", + "selector": "time.review-date", + "type": "attribute", + "attribute": "datetime" + } + ] + } + ] + } + ] +} + +async def extract_with_css_schema(): + strategy = JsonCssExtractionStrategy(complex_schema, verbose=True) + + config = CrawlerRunConfig( + extraction_strategy=strategy, + cache_mode=CacheMode.BYPASS, + # Enable dynamic content loading if needed + js_code="window.scrollTo(0, document.body.scrollHeight);", + wait_for="css:.product:nth-child(10)", # Wait for products to load + process_iframes=True + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun( + url="https://example.com/catalog", + config=config + ) + + if result.success: + data = json.loads(result.extracted_content) + print(f"Extracted {len(data)} categories") + + for category in data: + print(f"Category: {category['category_name']}") + print(f"Products: {len(category.get('products', []))}") + + # Show first product details + if category.get('products'): + product = category['products'][0] + print(f" First product: {product.get('name')}") + print(f" Features: {len(product.get('features', []))}") + print(f" Reviews: {len(product.get('reviews', []))}") + +asyncio.run(extract_with_css_schema()) +``` + +### Automatic Schema Generation - One-Time LLM, Unlimited Use + +```python +import json +import asyncio +from pathlib import Path +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, LLMConfig +from crawl4ai.extraction_strategy import JsonCssExtractionStrategy + +async def generate_and_use_schema(): + """ + 1. Use LLM once to generate schema from sample HTML + 2. Cache the schema for reuse + 3. Use cached schema for fast extraction without LLM calls + """ + + cache_dir = Path("./schema_cache") + cache_dir.mkdir(exist_ok=True) + schema_file = cache_dir / "ecommerce_schema.json" + + # Step 1: Generate or load cached schema + if schema_file.exists(): + schema = json.load(schema_file.open()) + print("Using cached schema") + else: + print("Generating schema using LLM...") + + # Configure LLM for schema generation + llm_config = LLMConfig( + provider="openai/gpt-4o", # or "ollama/llama3.3" for local + api_token="env:OPENAI_API_KEY" + ) + + # Get sample HTML from target site + async with AsyncWebCrawler() as crawler: + sample_result = await crawler.arun( + url="https://example.com/products", + config=CrawlerRunConfig(cache_mode=CacheMode.BYPASS) + ) + sample_html = sample_result.cleaned_html[:5000] # Use first 5k chars + + # Generate schema automatically (ONE-TIME LLM COST) + schema = JsonCssExtractionStrategy.generate_schema( + html=sample_html, + schema_type="css", + llm_config=llm_config, + instruction="Extract product information including name, price, description, and features" + ) + + # Cache schema for future use (NO MORE LLM CALLS) + json.dump(schema, schema_file.open("w"), indent=2) + print("Schema generated and cached") + + # Step 2: Use schema for fast extraction (NO LLM CALLS) + strategy = JsonCssExtractionStrategy(schema, verbose=True) + + config = CrawlerRunConfig( + extraction_strategy=strategy, + cache_mode=CacheMode.BYPASS + ) + + # Step 3: Extract from multiple pages using same schema + urls = [ + "https://example.com/products", + "https://example.com/electronics", + "https://example.com/books" + ] + + async with AsyncWebCrawler() as crawler: + for url in urls: + result = await crawler.arun(url=url, config=config) + + if result.success: + data = json.loads(result.extracted_content) + print(f"{url}: Extracted {len(data)} items") + else: + print(f"{url}: Failed - {result.error_message}") + +asyncio.run(generate_and_use_schema()) +``` + +### XPath Extraction Strategy + +```python +from crawl4ai.extraction_strategy import JsonXPathExtractionStrategy + +# XPath-based schema (alternative to CSS) +xpath_schema = { + "name": "News Articles", + "baseSelector": "//article[@class='news-item']", + "baseFields": [ + { + "name": "article_id", + "type": "attribute", + "attribute": "data-id" + } + ], + "fields": [ + { + "name": "headline", + "selector": ".//h2[@class='headline']", + "type": "text" + }, + { + "name": "author", + "selector": ".//span[@class='author']/text()", + "type": "text" + }, + { + "name": "publish_date", + "selector": ".//time/@datetime", + "type": "text" + }, + { + "name": "content", + "selector": ".//div[@class='article-body']", + "type": "html" + }, + { + "name": "tags", + "selector": ".//div[@class='tags']/span[@class='tag']", + "type": "list", + "fields": [ + {"name": "tag", "type": "text"} + ] + } + ] +} + +# Generate XPath schema automatically +async def generate_xpath_schema(): + llm_config = LLMConfig(provider="ollama/llama3.3", api_token=None) + + sample_html = """ +Content here...
Content
" + result = await strategy.crawl(raw_html) + print(f"Raw content: {result.html}") + + # Raw content with complex HTML + complex_html = """raw:// + +Paragraph content
+Sample text
" + result3 = await crawler.arun(f"raw:{raw_html}") + + # All return the same CrawlResult structure + for i, result in enumerate([result1, result2, result3], 1): + if result.success: + print(f"Input {i}: {len(result.markdown)} chars of markdown") + +# Save and re-process HTML example +async def save_and_reprocess(): + async with AsyncWebCrawler() as crawler: + # Original crawl + result = await crawler.arun("https://example.com") + + if result.success: + # Save HTML to file + with open("saved_page.html", "w", encoding="utf-8") as f: + f.write(result.html) + + # Re-process from file + file_result = await crawler.arun("file://./saved_page.html") + + # Process as raw HTML + raw_result = await crawler.arun(f"raw:{result.html}") + + # Verify consistency + assert len(result.markdown) == len(file_result.markdown) == len(raw_result.markdown) + print("✅ All processing methods produced identical results") +``` + +### Advanced Link & Media Handling + +```python +# Comprehensive link and media extraction with filtering +async def advanced_link_media_handling(): + config = CrawlerRunConfig( + # Link filtering + exclude_external_links=False, # Keep external links for analysis + exclude_social_media_links=True, + exclude_domains=["ads.com", "tracker.io", "spammy.net"], + + # Media handling + exclude_external_images=True, + image_score_threshold=5, # Only high-quality images + table_score_threshold=7, # Only well-structured tables + wait_for_images=True, + + # Capture additional formats + screenshot=True, + pdf=True, + capture_mhtml=True # Full page archive + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://example.com", config=config) + + if result.success: + # Analyze links + internal_links = result.links.get("internal", []) + external_links = result.links.get("external", []) + print(f"Links: {len(internal_links)} internal, {len(external_links)} external") + + # Analyze media + images = result.media.get("images", []) + tables = result.media.get("tables", []) + print(f"Media: {len(images)} images, {len(tables)} tables") + + # High-quality images only + quality_images = [img for img in images if img.get("score", 0) >= 5] + print(f"High-quality images: {len(quality_images)}") + + # Table analysis + for i, table in enumerate(tables[:2]): + print(f"Table {i+1}: {len(table.get('headers', []))} columns, {len(table.get('rows', []))} rows") + + # Save captured files + if result.screenshot: + import base64 + with open("page_screenshot.png", "wb") as f: + f.write(base64.b64decode(result.screenshot)) + + if result.pdf: + with open("page.pdf", "wb") as f: + f.write(result.pdf) + + if result.mhtml: + with open("page_archive.mhtml", "w", encoding="utf-8") as f: + f.write(result.mhtml) + + print("Additional formats saved: screenshot, PDF, MHTML archive") +``` + +### Performance & Resource Management + +```python +# Optimize performance for large-scale crawling +async def performance_optimized_crawling(): + # Lightweight browser config + browser_config = BrowserConfig( + headless=True, + text_mode=True, # Disable images for speed + light_mode=True, # Reduce background features + extra_args=["--disable-extensions", "--no-sandbox"] + ) + + # Efficient crawl config + config = CrawlerRunConfig( + # Content filtering for speed + excluded_tags=["script", "style", "nav", "footer"], + exclude_external_links=True, + exclude_all_images=True, # Remove all images for max speed + word_count_threshold=50, + + # Timing optimizations + page_timeout=30000, # Faster timeout + delay_before_return_html=0.1, + + # Resource monitoring + capture_network_requests=False, # Disable unless needed + capture_console_messages=False, + + # Cache for repeated URLs + cache_mode=CacheMode.ENABLED + ) + + async with AsyncWebCrawler(config=browser_config) as crawler: + urls = ["https://example.com/page1", "https://example.com/page2", "https://example.com/page3"] + + # Efficient batch processing + batch_config = config.clone( + stream=True, # Stream results as they complete + semaphore_count=3 # Control concurrency + ) + + async for result in await crawler.arun_many(urls, config=batch_config): + if result.success: + print(f"✅ {result.url}: {len(result.markdown)} chars") + else: + print(f"❌ {result.url}: {result.error_message}") +``` + +**📖 Learn more:** [Hooks & Authentication](https://docs.crawl4ai.com/advanced/hooks-auth/), [Session Management](https://docs.crawl4ai.com/advanced/session-management/), [Network Monitoring](https://docs.crawl4ai.com/advanced/network-console-capture/), [Page Interaction](https://docs.crawl4ai.com/core/page-interaction/), [File Downloads](https://docs.crawl4ai.com/advanced/file-downloading/) +--- + + +## Deep Crawling Filters & Scorers + +Advanced URL filtering and scoring strategies for intelligent deep crawling with performance optimization. + +### URL Filters - Content and Domain Control + +```python +from crawl4ai.deep_crawling.filters import ( + URLPatternFilter, DomainFilter, ContentTypeFilter, + FilterChain, ContentRelevanceFilter, SEOFilter +) + +# Pattern-based filtering +pattern_filter = URLPatternFilter( + patterns=[ + "*.html", # HTML pages only + "*/blog/*", # Blog posts + "*/articles/*", # Article pages + "*2024*", # Recent content + "^https://example.com/docs/.*" # Regex pattern + ], + use_glob=True, + reverse=False # False = include matching, True = exclude matching +) + +# Domain filtering with subdomains +domain_filter = DomainFilter( + allowed_domains=["example.com", "docs.example.com"], + blocked_domains=["ads.example.com", "tracker.com"] +) + +# Content type filtering +content_filter = ContentTypeFilter( + allowed_types=["text/html", "application/pdf"], + check_extension=True +) + +# Apply individual filters +url = "https://example.com/blog/2024/article.html" +print(f"Pattern filter: {pattern_filter.apply(url)}") +print(f"Domain filter: {domain_filter.apply(url)}") +print(f"Content filter: {content_filter.apply(url)}") +``` + +### Filter Chaining - Combine Multiple Filters + +```python +# Create filter chain for comprehensive filtering +filter_chain = FilterChain([ + DomainFilter(allowed_domains=["example.com"]), + URLPatternFilter(patterns=["*/blog/*", "*/docs/*"]), + ContentTypeFilter(allowed_types=["text/html"]) +]) + +# Apply chain to URLs +urls = [ + "https://example.com/blog/post1.html", + "https://spam.com/content.html", + "https://example.com/blog/image.jpg", + "https://example.com/docs/guide.html" +] + +async def filter_urls(urls, filter_chain): + filtered = [] + for url in urls: + if await filter_chain.apply(url): + filtered.append(url) + return filtered + +# Usage +filtered_urls = await filter_urls(urls, filter_chain) +print(f"Filtered URLs: {filtered_urls}") + +# Check filter statistics +for filter_obj in filter_chain.filters: + stats = filter_obj.stats + print(f"{filter_obj.name}: {stats.passed_urls}/{stats.total_urls} passed") +``` + +### Advanced Content Filters + +```python +# BM25-based content relevance filtering +relevance_filter = ContentRelevanceFilter( + query="python machine learning tutorial", + threshold=0.5, # Minimum relevance score + k1=1.2, # TF saturation parameter + b=0.75, # Length normalization + avgdl=1000 # Average document length +) + +# SEO quality filtering +seo_filter = SEOFilter( + threshold=0.65, # Minimum SEO score + keywords=["python", "tutorial", "guide"], + weights={ + "title_length": 0.15, + "title_kw": 0.18, + "meta_description": 0.12, + "canonical": 0.10, + "robot_ok": 0.20, + "schema_org": 0.10, + "url_quality": 0.15 + } +) + +# Apply advanced filters +url = "https://example.com/python-ml-tutorial" +relevance_score = await relevance_filter.apply(url) +seo_score = await seo_filter.apply(url) + +print(f"Relevance: {relevance_score}, SEO: {seo_score}") +``` + +### URL Scorers - Quality and Relevance Scoring + +```python +from crawl4ai.deep_crawling.scorers import ( + KeywordRelevanceScorer, PathDepthScorer, ContentTypeScorer, + FreshnessScorer, DomainAuthorityScorer, CompositeScorer +) + +# Keyword relevance scoring +keyword_scorer = KeywordRelevanceScorer( + keywords=["python", "tutorial", "guide", "machine", "learning"], + weight=1.0, + case_sensitive=False +) + +# Path depth scoring (optimal depth = 3) +depth_scorer = PathDepthScorer( + optimal_depth=3, # /category/subcategory/article + weight=0.8 +) + +# Content type scoring +content_type_scorer = ContentTypeScorer( + type_weights={ + "html": 1.0, # Highest priority + "pdf": 0.8, # Medium priority + "txt": 0.6, # Lower priority + "doc": 0.4 # Lowest priority + }, + weight=0.9 +) + +# Freshness scoring +freshness_scorer = FreshnessScorer( + weight=0.7, + current_year=2024 +) + +# Domain authority scoring +domain_scorer = DomainAuthorityScorer( + domain_weights={ + "python.org": 1.0, + "github.com": 0.9, + "stackoverflow.com": 0.85, + "medium.com": 0.7, + "personal-blog.com": 0.3 + }, + default_weight=0.5, + weight=1.0 +) + +# Score individual URLs +url = "https://python.org/tutorial/2024/machine-learning.html" +scores = { + "keyword": keyword_scorer.score(url), + "depth": depth_scorer.score(url), + "content": content_type_scorer.score(url), + "freshness": freshness_scorer.score(url), + "domain": domain_scorer.score(url) +} + +print(f"Individual scores: {scores}") +``` + +### Composite Scoring - Combine Multiple Scorers + +```python +# Create composite scorer combining all strategies +composite_scorer = CompositeScorer( + scorers=[ + KeywordRelevanceScorer(["python", "tutorial"], weight=1.5), + PathDepthScorer(optimal_depth=3, weight=1.0), + ContentTypeScorer({"html": 1.0, "pdf": 0.8}, weight=1.2), + FreshnessScorer(weight=0.8, current_year=2024), + DomainAuthorityScorer({ + "python.org": 1.0, + "github.com": 0.9 + }, weight=1.3) + ], + normalize=True # Normalize by number of scorers +) + +# Score multiple URLs +urls_to_score = [ + "https://python.org/tutorial/2024/basics.html", + "https://github.com/user/python-guide/blob/main/README.md", + "https://random-blog.com/old/2018/python-stuff.html", + "https://python.org/docs/deep/nested/advanced/guide.html" +] + +scored_urls = [] +for url in urls_to_score: + score = composite_scorer.score(url) + scored_urls.append((url, score)) + +# Sort by score (highest first) +scored_urls.sort(key=lambda x: x[1], reverse=True) + +for url, score in scored_urls: + print(f"Score: {score:.3f} - {url}") + +# Check scorer statistics +print(f"\nScoring statistics:") +print(f"URLs scored: {composite_scorer.stats._urls_scored}") +print(f"Average score: {composite_scorer.stats.get_average():.3f}") +``` + +### Advanced Filter Patterns + +```python +# Complex pattern matching +advanced_patterns = URLPatternFilter( + patterns=[ + r"^https://docs\.python\.org/\d+/", # Python docs with version + r".*/tutorial/.*\.html$", # Tutorial pages + r".*/guide/(?!deprecated).*", # Guides but not deprecated + "*/blog/{2020,2021,2022,2023,2024}/*", # Recent blog posts + "**/{api,reference}/**/*.html" # API/reference docs + ], + use_glob=True +) + +# Exclude patterns (reverse=True) +exclude_filter = URLPatternFilter( + patterns=[ + "*/admin/*", + "*/login/*", + "*/private/*", + "**/.*", # Hidden files + "*.{jpg,png,gif,css,js}$" # Media and assets + ], + reverse=True # Exclude matching patterns +) + +# Content type with extension mapping +detailed_content_filter = ContentTypeFilter( + allowed_types=["text", "application"], + check_extension=True, + ext_map={ + "html": "text/html", + "htm": "text/html", + "md": "text/markdown", + "pdf": "application/pdf", + "doc": "application/msword", + "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document" + } +) +``` + +### Performance-Optimized Filtering + +```python +# High-performance filter chain for large-scale crawling +class OptimizedFilterChain: + def __init__(self): + # Fast filters first (domain, patterns) + self.fast_filters = [ + DomainFilter( + allowed_domains=["example.com", "docs.example.com"], + blocked_domains=["ads.example.com"] + ), + URLPatternFilter([ + "*.html", "*.pdf", "*/blog/*", "*/docs/*" + ]) + ] + + # Slower filters last (content analysis) + self.slow_filters = [ + ContentRelevanceFilter( + query="important content", + threshold=0.3 + ) + ] + + async def apply_optimized(self, url: str) -> bool: + # Apply fast filters first + for filter_obj in self.fast_filters: + if not filter_obj.apply(url): + return False + + # Only apply slow filters if fast filters pass + for filter_obj in self.slow_filters: + if not await filter_obj.apply(url): + return False + + return True + +# Batch filtering with concurrency +async def batch_filter_urls(urls, filter_chain, max_concurrent=50): + import asyncio + semaphore = asyncio.Semaphore(max_concurrent) + + async def filter_single(url): + async with semaphore: + return await filter_chain.apply(url), url + + tasks = [filter_single(url) for url in urls] + results = await asyncio.gather(*tasks) + + return [url for passed, url in results if passed] + +# Usage with 1000 URLs +large_url_list = [f"https://example.com/page{i}.html" for i in range(1000)] +optimized_chain = OptimizedFilterChain() +filtered = await batch_filter_urls(large_url_list, optimized_chain) +``` + +### Custom Filter Implementation + +```python +from crawl4ai.deep_crawling.filters import URLFilter +import re + +class CustomLanguageFilter(URLFilter): + """Filter URLs by language indicators""" + + def __init__(self, allowed_languages=["en"], weight=1.0): + super().__init__() + self.allowed_languages = set(allowed_languages) + self.lang_patterns = { + "en": re.compile(r"/en/|/english/|lang=en"), + "es": re.compile(r"/es/|/spanish/|lang=es"), + "fr": re.compile(r"/fr/|/french/|lang=fr"), + "de": re.compile(r"/de/|/german/|lang=de") + } + + def apply(self, url: str) -> bool: + # Default to English if no language indicators + if not any(pattern.search(url) for pattern in self.lang_patterns.values()): + result = "en" in self.allowed_languages + self._update_stats(result) + return result + + # Check for allowed languages + for lang in self.allowed_languages: + if lang in self.lang_patterns: + if self.lang_patterns[lang].search(url): + self._update_stats(True) + return True + + self._update_stats(False) + return False + +# Custom scorer implementation +from crawl4ai.deep_crawling.scorers import URLScorer + +class CustomComplexityScorer(URLScorer): + """Score URLs by content complexity indicators""" + + def __init__(self, weight=1.0): + super().__init__(weight) + self.complexity_indicators = { + "tutorial": 0.9, + "guide": 0.8, + "example": 0.7, + "reference": 0.6, + "api": 0.5 + } + + def _calculate_score(self, url: str) -> float: + url_lower = url.lower() + max_score = 0.0 + + for indicator, score in self.complexity_indicators.items(): + if indicator in url_lower: + max_score = max(max_score, score) + + return max_score + +# Use custom filters and scorers +custom_filter = CustomLanguageFilter(allowed_languages=["en", "es"]) +custom_scorer = CustomComplexityScorer(weight=1.2) + +url = "https://example.com/en/tutorial/advanced-guide.html" +passes_filter = custom_filter.apply(url) +complexity_score = custom_scorer.score(url) + +print(f"Passes language filter: {passes_filter}") +print(f"Complexity score: {complexity_score}") +``` + +### Integration with Deep Crawling + +```python +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig +from crawl4ai.deep_crawling import DeepCrawlStrategy + +async def deep_crawl_with_filtering(): + # Create comprehensive filter chain + filter_chain = FilterChain([ + DomainFilter(allowed_domains=["python.org"]), + URLPatternFilter(["*/tutorial/*", "*/guide/*", "*/docs/*"]), + ContentTypeFilter(["text/html"]), + SEOFilter(threshold=0.6, keywords=["python", "programming"]) + ]) + + # Create composite scorer + scorer = CompositeScorer([ + KeywordRelevanceScorer(["python", "tutorial"], weight=1.5), + FreshnessScorer(weight=0.8), + PathDepthScorer(optimal_depth=3, weight=1.0) + ], normalize=True) + + # Configure deep crawl strategy with filters and scorers + deep_strategy = DeepCrawlStrategy( + max_depth=3, + max_pages=100, + url_filter=filter_chain, + url_scorer=scorer, + score_threshold=0.6 # Only crawl URLs scoring above 0.6 + ) + + config = CrawlerRunConfig( + deep_crawl_strategy=deep_strategy, + cache_mode=CacheMode.BYPASS + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun( + url="https://python.org", + config=config + ) + + print(f"Deep crawl completed: {result.success}") + if hasattr(result, 'deep_crawl_results'): + print(f"Pages crawled: {len(result.deep_crawl_results)}") + +# Run the deep crawl +await deep_crawl_with_filtering() +``` + +**📖 Learn more:** [Deep Crawling Strategy](https://docs.crawl4ai.com/core/deep-crawling/), [Custom Filter Development](https://docs.crawl4ai.com/advanced/custom-filters/), [Performance Optimization](https://docs.crawl4ai.com/advanced/performance-tuning/) +--- + + +## Summary + +Crawl4AI provides a comprehensive solution for web crawling and data extraction optimized for AI applications. From simple page crawling to complex multi-URL operations with advanced filtering, the library offers the flexibility and performance needed for modern data extraction workflows. + +**Key Takeaways:** +- Start with basic installation and simple crawling patterns +- Use configuration objects for consistent, maintainable code +- Choose appropriate extraction strategies based on your data structure +- Leverage Docker for production deployments +- Implement advanced features like deep crawling and custom filters as needed + +**Next Steps:** +- Explore the [GitHub repository](https://github.com/unclecode/crawl4ai) for latest updates +- Join the [Discord community](https://discord.gg/jP8KfhDhyN) for support +- Check out [example projects](https://github.com/unclecode/crawl4ai/tree/main/docs/examples) for inspiration + +Happy crawling! 🕷️ diff --git a/docs/md_v2/assets/llm.txt/txt/multi_urls_crawling.txt b/docs/md_v2/assets/llm.txt/txt/multi_urls_crawling.txt new file mode 100644 index 00000000..4aea4dc4 --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/multi_urls_crawling.txt @@ -0,0 +1,339 @@ +## Multi-URL Crawling + +Concurrent crawling of multiple URLs with intelligent resource management, rate limiting, and real-time monitoring. + +### Basic Multi-URL Crawling + +```python +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode + +# Batch processing (default) - get all results at once +async def batch_crawl(): + urls = [ + "https://example.com/page1", + "https://example.com/page2", + "https://example.com/page3" + ] + + config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + stream=False # Default: batch mode + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun_many(urls, config=config) + + for result in results: + if result.success: + print(f"✅ {result.url}: {len(result.markdown)} chars") + else: + print(f"❌ {result.url}: {result.error_message}") + +# Streaming processing - handle results as they complete +async def streaming_crawl(): + config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + stream=True # Enable streaming + ) + + async with AsyncWebCrawler() as crawler: + # Process results as they become available + async for result in await crawler.arun_many(urls, config=config): + if result.success: + print(f"🔥 Just completed: {result.url}") + await process_result_immediately(result) + else: + print(f"❌ Failed: {result.url}") +``` + +### Memory-Adaptive Dispatching + +```python +from crawl4ai import AsyncWebCrawler, MemoryAdaptiveDispatcher, CrawlerMonitor, DisplayMode + +# Automatically manages concurrency based on system memory +async def memory_adaptive_crawl(): + dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=80.0, # Pause if memory exceeds 80% + check_interval=1.0, # Check memory every second + max_session_permit=15, # Max concurrent tasks + memory_wait_timeout=300.0 # Wait up to 5 minutes for memory + ) + + config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + word_count_threshold=50 + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun_many( + urls=large_url_list, + config=config, + dispatcher=dispatcher + ) + + # Each result includes dispatch information + for result in results: + if result.dispatch_result: + dr = result.dispatch_result + print(f"Memory used: {dr.memory_usage:.1f}MB") + print(f"Duration: {dr.end_time - dr.start_time}") +``` + +### Rate-Limited Crawling + +```python +from crawl4ai import RateLimiter, SemaphoreDispatcher + +# Control request pacing and handle server rate limits +async def rate_limited_crawl(): + rate_limiter = RateLimiter( + base_delay=(1.0, 3.0), # Random delay 1-3 seconds + max_delay=60.0, # Cap backoff at 60 seconds + max_retries=3, # Retry failed requests 3 times + rate_limit_codes=[429, 503] # Handle these status codes + ) + + dispatcher = SemaphoreDispatcher( + max_session_permit=5, # Fixed concurrency limit + rate_limiter=rate_limiter + ) + + config = CrawlerRunConfig( + user_agent_mode="random", # Randomize user agents + simulate_user=True # Simulate human behavior + ) + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun_many( + urls=urls, + config=config, + dispatcher=dispatcher + ): + print(f"Processed: {result.url}") +``` + +### Real-Time Monitoring + +```python +from crawl4ai import CrawlerMonitor, DisplayMode + +# Monitor crawling progress in real-time +async def monitored_crawl(): + monitor = CrawlerMonitor( + max_visible_rows=20, # Show 20 tasks in display + display_mode=DisplayMode.DETAILED # Show individual task details + ) + + dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=75.0, + max_session_permit=10, + monitor=monitor # Attach monitor to dispatcher + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun_many( + urls=urls, + dispatcher=dispatcher + ) +``` + +### Advanced Dispatcher Configurations + +```python +# Memory-adaptive with comprehensive monitoring +memory_dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=85.0, # Higher memory tolerance + check_interval=0.5, # Check memory more frequently + max_session_permit=20, # More concurrent tasks + memory_wait_timeout=600.0, # Wait longer for memory + rate_limiter=RateLimiter( + base_delay=(0.5, 1.5), + max_delay=30.0, + max_retries=5 + ), + monitor=CrawlerMonitor( + max_visible_rows=15, + display_mode=DisplayMode.AGGREGATED # Summary view + ) +) + +# Simple semaphore-based dispatcher +semaphore_dispatcher = SemaphoreDispatcher( + max_session_permit=8, # Fixed concurrency + rate_limiter=RateLimiter( + base_delay=(1.0, 2.0), + max_delay=20.0 + ) +) + +# Usage with custom dispatcher +async with AsyncWebCrawler() as crawler: + results = await crawler.arun_many( + urls=urls, + config=config, + dispatcher=memory_dispatcher # or semaphore_dispatcher + ) +``` + +### Handling Large-Scale Crawling + +```python +async def large_scale_crawl(): + # For thousands of URLs + urls = load_urls_from_file("large_url_list.txt") # 10,000+ URLs + + dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=70.0, # Conservative memory usage + max_session_permit=25, # Higher concurrency + rate_limiter=RateLimiter( + base_delay=(0.1, 0.5), # Faster for large batches + max_retries=2 # Fewer retries for speed + ), + monitor=CrawlerMonitor(display_mode=DisplayMode.AGGREGATED) + ) + + config = CrawlerRunConfig( + cache_mode=CacheMode.ENABLED, # Use caching for efficiency + stream=True, # Stream for memory efficiency + word_count_threshold=100, # Skip short content + exclude_external_links=True # Reduce processing overhead + ) + + successful_crawls = 0 + failed_crawls = 0 + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun_many( + urls=urls, + config=config, + dispatcher=dispatcher + ): + if result.success: + successful_crawls += 1 + await save_result_to_database(result) + else: + failed_crawls += 1 + await log_failure(result.url, result.error_message) + + # Progress reporting + if (successful_crawls + failed_crawls) % 100 == 0: + print(f"Progress: {successful_crawls + failed_crawls}/{len(urls)}") + + print(f"Completed: {successful_crawls} successful, {failed_crawls} failed") +``` + +### Robots.txt Compliance + +```python +async def compliant_crawl(): + config = CrawlerRunConfig( + check_robots_txt=True, # Respect robots.txt + user_agent="MyBot/1.0", # Identify your bot + mean_delay=2.0, # Be polite with delays + max_range=1.0 + ) + + dispatcher = SemaphoreDispatcher( + max_session_permit=3, # Conservative concurrency + rate_limiter=RateLimiter( + base_delay=(2.0, 5.0), # Slower, more respectful + max_retries=1 + ) + ) + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun_many( + urls=urls, + config=config, + dispatcher=dispatcher + ): + if result.success: + print(f"✅ Crawled: {result.url}") + elif "robots.txt" in result.error_message: + print(f"🚫 Blocked by robots.txt: {result.url}") + else: + print(f"❌ Error: {result.url}") +``` + +### Performance Analysis + +```python +async def analyze_crawl_performance(): + dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=80.0, + max_session_permit=12, + monitor=CrawlerMonitor(display_mode=DisplayMode.DETAILED) + ) + + start_time = time.time() + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun_many( + urls=urls, + dispatcher=dispatcher + ) + + end_time = time.time() + + # Analyze results + successful = [r for r in results if r.success] + failed = [r for r in results if not r.success] + + print(f"Total time: {end_time - start_time:.2f}s") + print(f"Success rate: {len(successful)}/{len(results)} ({len(successful)/len(results)*100:.1f}%)") + print(f"Avg time per URL: {(end_time - start_time)/len(results):.2f}s") + + # Memory usage analysis + if successful and successful[0].dispatch_result: + memory_usage = [r.dispatch_result.memory_usage for r in successful if r.dispatch_result] + peak_memory = [r.dispatch_result.peak_memory for r in successful if r.dispatch_result] + + print(f"Avg memory usage: {sum(memory_usage)/len(memory_usage):.1f}MB") + print(f"Peak memory usage: {max(peak_memory):.1f}MB") +``` + +### Error Handling and Recovery + +```python +async def robust_multi_crawl(): + failed_urls = [] + + config = CrawlerRunConfig( + cache_mode=CacheMode.BYPASS, + stream=True, + page_timeout=30000 # 30 second timeout + ) + + dispatcher = MemoryAdaptiveDispatcher( + memory_threshold_percent=85.0, + max_session_permit=10 + ) + + async with AsyncWebCrawler() as crawler: + async for result in await crawler.arun_many( + urls=urls, + config=config, + dispatcher=dispatcher + ): + if result.success: + await process_successful_result(result) + else: + failed_urls.append({ + 'url': result.url, + 'error': result.error_message, + 'status_code': result.status_code + }) + + # Retry logic for specific errors + if result.status_code in [503, 429]: # Server errors + await schedule_retry(result.url) + + # Report failures + if failed_urls: + print(f"Failed to crawl {len(failed_urls)} URLs:") + for failure in failed_urls[:10]: # Show first 10 + print(f" {failure['url']}: {failure['error']}") +``` + +**📖 Learn more:** [Advanced Multi-URL Crawling](https://docs.crawl4ai.com/advanced/multi-url-crawling/), [Crawl Dispatcher](https://docs.crawl4ai.com/advanced/crawl-dispatcher/), [arun_many() API Reference](https://docs.crawl4ai.com/api/arun_many/) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/simple_crawling.txt b/docs/md_v2/assets/llm.txt/txt/simple_crawling.txt new file mode 100644 index 00000000..a9c4accb --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/simple_crawling.txt @@ -0,0 +1,365 @@ +## Simple Crawling + +Basic web crawling operations with AsyncWebCrawler, configurations, and response handling. + +### Basic Setup + +```python +import asyncio +from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig + +async def main(): + browser_config = BrowserConfig() # Default browser settings + run_config = CrawlerRunConfig() # Default crawl settings + + async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun( + url="https://example.com", + config=run_config + ) + print(result.markdown) + +if __name__ == "__main__": + asyncio.run(main()) +``` + +### Understanding CrawlResult + +```python +from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator +from crawl4ai.content_filter_strategy import PruningContentFilter + +config = CrawlerRunConfig( + markdown_generator=DefaultMarkdownGenerator( + content_filter=PruningContentFilter(threshold=0.6), + options={"ignore_links": True} + ) +) + +result = await crawler.arun("https://example.com", config=config) + +# Different content formats +print(result.html) # Raw HTML +print(result.cleaned_html) # Cleaned HTML +print(result.markdown.raw_markdown) # Raw markdown +print(result.markdown.fit_markdown) # Filtered markdown + +# Status information +print(result.success) # True/False +print(result.status_code) # HTTP status (200, 404, etc.) + +# Extracted content +print(result.media) # Images, videos, audio +print(result.links) # Internal/external links +``` + +### Basic Configuration Options + +```python +run_config = CrawlerRunConfig( + word_count_threshold=10, # Min words per block + exclude_external_links=True, # Remove external links + remove_overlay_elements=True, # Remove popups/modals + process_iframes=True, # Process iframe content + excluded_tags=['form', 'header'] # Skip these tags +) + +result = await crawler.arun("https://example.com", config=run_config) +``` + +### Error Handling + +```python +result = await crawler.arun("https://example.com", config=run_config) + +if not result.success: + print(f"Crawl failed: {result.error_message}") + print(f"Status code: {result.status_code}") +else: + print(f"Success! Content length: {len(result.markdown)}") +``` + +### Debugging with Verbose Logging + +```python +browser_config = BrowserConfig(verbose=True) + +async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun("https://example.com") + # Detailed logging output will be displayed +``` + +### Complete Example + +```python +import asyncio +from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode + +async def comprehensive_crawl(): + browser_config = BrowserConfig(verbose=True) + + run_config = CrawlerRunConfig( + # Content filtering + word_count_threshold=10, + excluded_tags=['form', 'header', 'nav'], + exclude_external_links=True, + + # Content processing + process_iframes=True, + remove_overlay_elements=True, + + # Cache control + cache_mode=CacheMode.ENABLED + ) + + async with AsyncWebCrawler(config=browser_config) as crawler: + result = await crawler.arun( + url="https://example.com", + config=run_config + ) + + if result.success: + # Display content summary + print(f"Title: {result.metadata.get('title', 'No title')}") + print(f"Content: {result.markdown[:500]}...") + + # Process media + images = result.media.get("images", []) + print(f"Found {len(images)} images") + for img in images[:3]: # First 3 images + print(f" - {img.get('src', 'No src')}") + + # Process links + internal_links = result.links.get("internal", []) + print(f"Found {len(internal_links)} internal links") + for link in internal_links[:3]: # First 3 links + print(f" - {link.get('href', 'No href')}") + + else: + print(f"❌ Crawl failed: {result.error_message}") + print(f"Status: {result.status_code}") + +if __name__ == "__main__": + asyncio.run(comprehensive_crawl()) +``` + +### Working with Raw HTML and Local Files + +```python +# Crawl raw HTML +raw_html = "Content
" +result = await crawler.arun(f"raw://{raw_html}") + +# Crawl local file +result = await crawler.arun("file:///path/to/local/file.html") + +# Both return standard CrawlResult objects +print(result.markdown) +``` + +## Table Extraction + +Extract structured data from HTML tables with automatic detection and scoring. + +### Basic Table Extraction + +```python +import asyncio +import pandas as pd +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode + +async def extract_tables(): + async with AsyncWebCrawler() as crawler: + config = CrawlerRunConfig( + table_score_threshold=7, # Higher = stricter detection + cache_mode=CacheMode.BYPASS + ) + + result = await crawler.arun("https://example.com/tables", config=config) + + if result.success and result.tables: + # New tables field (v0.6+) + for i, table in enumerate(result.tables): + print(f"Table {i+1}:") + print(f"Headers: {table['headers']}") + print(f"Rows: {len(table['rows'])}") + print(f"Caption: {table.get('caption', 'No caption')}") + + # Convert to DataFrame + df = pd.DataFrame(table['rows'], columns=table['headers']) + print(df.head()) + +asyncio.run(extract_tables()) +``` + +### Advanced Table Processing + +```python +from crawl4ai import LXMLWebScrapingStrategy + +async def process_financial_tables(): + config = CrawlerRunConfig( + table_score_threshold=8, # Strict detection for data tables + scraping_strategy=LXMLWebScrapingStrategy(), + keep_data_attributes=True, + scan_full_page=True + ) + + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://coinmarketcap.com", config=config) + + if result.tables: + # Get the main data table (usually first/largest) + main_table = result.tables[0] + + # Create DataFrame + df = pd.DataFrame( + main_table['rows'], + columns=main_table['headers'] + ) + + # Clean and process data + df = clean_financial_data(df) + + # Save for analysis + df.to_csv("market_data.csv", index=False) + return df + +def clean_financial_data(df): + """Clean currency symbols, percentages, and large numbers""" + for col in df.columns: + if 'price' in col.lower(): + # Remove currency symbols + df[col] = df[col].str.replace(r'[^\d.]', '', regex=True) + df[col] = pd.to_numeric(df[col], errors='coerce') + + elif '%' in str(df[col].iloc[0]): + # Convert percentages + df[col] = df[col].str.replace('%', '').astype(float) / 100 + + elif any(suffix in str(df[col].iloc[0]) for suffix in ['B', 'M', 'K']): + # Handle large numbers (Billions, Millions, etc.) + df[col] = df[col].apply(convert_large_numbers) + + return df + +def convert_large_numbers(value): + """Convert 1.5B -> 1500000000""" + if pd.isna(value): + return float('nan') + + value = str(value) + multiplier = 1 + if 'B' in value: + multiplier = 1e9 + elif 'M' in value: + multiplier = 1e6 + elif 'K' in value: + multiplier = 1e3 + + number = float(re.sub(r'[^\d.]', '', value)) + return number * multiplier +``` + +### Table Detection Configuration + +```python +# Strict table detection (data-heavy pages) +strict_config = CrawlerRunConfig( + table_score_threshold=9, # Only high-quality tables + word_count_threshold=5, # Ignore sparse content + excluded_tags=['nav', 'footer'] # Skip navigation tables +) + +# Lenient detection (mixed content pages) +lenient_config = CrawlerRunConfig( + table_score_threshold=5, # Include layout tables + process_iframes=True, # Check embedded tables + scan_full_page=True # Scroll to load dynamic tables +) + +# Financial/data site optimization +financial_config = CrawlerRunConfig( + table_score_threshold=8, + scraping_strategy=LXMLWebScrapingStrategy(), + wait_for="css:table", # Wait for tables to load + scan_full_page=True, + scroll_delay=0.2 +) +``` + +### Multi-Table Processing + +```python +async def extract_all_tables(): + async with AsyncWebCrawler() as crawler: + result = await crawler.arun("https://example.com/data", config=config) + + tables_data = {} + + for i, table in enumerate(result.tables): + # Create meaningful names based on content + table_name = ( + table.get('caption') or + f"table_{i+1}_{table['headers'][0]}" + ).replace(' ', '_').lower() + + df = pd.DataFrame(table['rows'], columns=table['headers']) + + # Store with metadata + tables_data[table_name] = { + 'dataframe': df, + 'headers': table['headers'], + 'row_count': len(table['rows']), + 'caption': table.get('caption'), + 'summary': table.get('summary') + } + + return tables_data + +# Usage +tables = await extract_all_tables() +for name, data in tables.items(): + print(f"{name}: {data['row_count']} rows") + data['dataframe'].to_csv(f"{name}.csv") +``` + +### Backward Compatibility + +```python +# Support both new and old table formats +def get_tables(result): + # New format (v0.6+) + if hasattr(result, 'tables') and result.tables: + return result.tables + + # Fallback to media.tables (older versions) + return result.media.get('tables', []) + +# Usage in existing code +result = await crawler.arun(url, config=config) +tables = get_tables(result) + +for table in tables: + df = pd.DataFrame(table['rows'], columns=table['headers']) + # Process table data... +``` + +### Table Quality Scoring + +```python +# Understanding table_score_threshold values: +# 10: Only perfect data tables (headers + data rows) +# 8-9: High-quality tables (recommended for financial/data sites) +# 6-7: Mixed content tables (news sites, wikis) +# 4-5: Layout tables included (broader detection) +# 1-3: All table-like structures (very permissive) + +config = CrawlerRunConfig( + table_score_threshold=8, # Balanced detection + verbose=True # See scoring details in logs +) +``` + + +**📖 Learn more:** [CrawlResult API Reference](https://docs.crawl4ai.com/api/crawl-result/), [Browser & Crawler Configuration](https://docs.crawl4ai.com/core/browser-crawler-config/), [Cache Modes](https://docs.crawl4ai.com/core/cache-modes/) \ No newline at end of file diff --git a/docs/md_v2/assets/llm.txt/txt/url_seeder.txt b/docs/md_v2/assets/llm.txt/txt/url_seeder.txt new file mode 100644 index 00000000..d549b391 --- /dev/null +++ b/docs/md_v2/assets/llm.txt/txt/url_seeder.txt @@ -0,0 +1,655 @@ +## URL Seeding + +Smart URL discovery for efficient large-scale crawling. Discover thousands of URLs instantly, filter by relevance, then crawl only what matters. + +### Why URL Seeding vs Deep Crawling + +```python +# Deep Crawling: Real-time discovery (page by page) +from crawl4ai import AsyncWebCrawler, CrawlerRunConfig +from crawl4ai.deep_crawling import BFSDeepCrawlStrategy + +async def deep_crawl_example(): + config = CrawlerRunConfig( + deep_crawl_strategy=BFSDeepCrawlStrategy( + max_depth=2, + include_external=False, + max_pages=50 + ) + ) + + async with AsyncWebCrawler() as crawler: + results = await crawler.arun("https://example.com", config=config) + print(f"Discovered {len(results)} pages dynamically") + +# URL Seeding: Bulk discovery (thousands instantly) +from crawl4ai import AsyncUrlSeeder, SeedingConfig + +async def url_seeding_example(): + config = SeedingConfig( + source="sitemap+cc", + pattern="*/docs/*", + extract_head=True, + query="API documentation", + scoring_method="bm25", + max_urls=1000 + ) + + async with AsyncUrlSeeder() as seeder: + urls = await seeder.urls("example.com", config) + print(f"Discovered {len(urls)} URLs instantly") + # Now crawl only the most relevant ones +``` + +### Basic URL Discovery + +```python +import asyncio +from crawl4ai import AsyncUrlSeeder, SeedingConfig + +async def basic_discovery(): + # Context manager handles cleanup automatically + async with AsyncUrlSeeder() as seeder: + + # Simple discovery from sitemaps + config = SeedingConfig(source="sitemap") + urls = await seeder.urls("example.com", config) + + print(f"Found {len(urls)} URLs from sitemap") + for url in urls[:5]: + print(f" - {url['url']} (status: {url['status']})") + +# Manual cleanup (if needed) +async def manual_cleanup(): + seeder = AsyncUrlSeeder() + try: + config = SeedingConfig(source="cc") # Common Crawl + urls = await seeder.urls("example.com", config) + print(f"Found {len(urls)} URLs from Common Crawl") + finally: + await seeder.close() + +asyncio.run(basic_discovery()) +``` + +### Data Sources and Patterns + +```python +# Different data sources +configs = [ + SeedingConfig(source="sitemap"), # Fastest, official URLs + SeedingConfig(source="cc"), # Most comprehensive + SeedingConfig(source="sitemap+cc"), # Maximum coverage +] + +# URL pattern filtering +patterns = [ + SeedingConfig(pattern="*/blog/*"), # Blog posts only + SeedingConfig(pattern="*.html"), # HTML files only + SeedingConfig(pattern="*/product/*"), # Product pages + SeedingConfig(pattern="*/docs/api/*"), # API documentation + SeedingConfig(pattern="*"), # Everything +] + +# Advanced pattern usage +async def pattern_filtering(): + async with AsyncUrlSeeder() as seeder: + # Find all blog posts from 2024 + config = SeedingConfig( + source="sitemap", + pattern="*/blog/2024/*.html", + max_urls=100 + ) + + blog_urls = await seeder.urls("example.com", config) + + # Further filter by keywords in URL + python_posts = [ + url for url in blog_urls + if "python" in url['url'].lower() + ] + + print(f"Found {len(python_posts)} Python blog posts") +``` + +### SeedingConfig Parameters + +```python +from crawl4ai import SeedingConfig + +# Comprehensive configuration +config = SeedingConfig( + # Data sources + source="sitemap+cc", # "sitemap", "cc", "sitemap+cc" + pattern="*/docs/*", # URL pattern filter + + # Metadata extraction + extract_head=True, # Get metadata + live_check=True, # Verify URLs are accessible + + # Performance controls + max_urls=1000, # Limit results (-1 = unlimited) + concurrency=20, # Parallel workers + hits_per_sec=10, # Rate limiting + + # Relevance scoring + query="API documentation guide", # Search query + scoring_method="bm25", # Scoring algorithm + score_threshold=0.3, # Minimum relevance (0.0-1.0) + + # Cache and filtering + force=False, # Bypass cache + filter_nonsense_urls=True, # Remove utility URLs + verbose=True # Debug output +) + +# Quick configurations for common use cases +blog_config = SeedingConfig( + source="sitemap", + pattern="*/blog/*", + extract_head=True +) + +api_docs_config = SeedingConfig( + source="sitemap+cc", + pattern="*/docs/*", + query="API reference documentation", + scoring_method="bm25", + score_threshold=0.5 +) + +product_pages_config = SeedingConfig( + source="cc", + pattern="*/product/*", + live_check=True, + max_urls=500 +) +``` + +### Metadata Extraction and Analysis + +```python +async def metadata_extraction(): + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + extract_head=True, # Extract metadata + pattern="*/blog/*", + max_urls=50 + ) + + urls = await seeder.urls("example.com", config) + + # Analyze extracted metadata + for url in urls[:5]: + head_data = url['head_data'] + print(f"\nURL: {url['url']}") + print(f"Title: {head_data.get('title', 'No title')}") + + # Standard meta tags + meta = head_data.get('meta', {}) + print(f"Description: {meta.get('description', 'N/A')}") + print(f"Keywords: {meta.get('keywords', 'N/A')}") + print(f"Author: {meta.get('author', 'N/A')}") + + # Open Graph data + print(f"OG Image: {meta.get('og:image', 'N/A')}") + print(f"OG Type: {meta.get('og:type', 'N/A')}") + + # JSON-LD structured data + jsonld = head_data.get('jsonld', []) + if jsonld: + print(f"Structured data: {len(jsonld)} items") + for item in jsonld[:2]: + if isinstance(item, dict): + print(f" Type: {item.get('@type', 'Unknown')}") + print(f" Name: {item.get('name', 'N/A')}") + +# Filter by metadata +async def metadata_filtering(): + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + extract_head=True, + max_urls=100 + ) + + urls = await seeder.urls("news.example.com", config) + + # Filter by publication date (from JSON-LD) + from datetime import datetime, timedelta + recent_cutoff = datetime.now() - timedelta(days=7) + + recent_articles = [] + for url in urls: + for jsonld in url['head_data'].get('jsonld', []): + if isinstance(jsonld, dict) and 'datePublished' in jsonld: + try: + pub_date = datetime.fromisoformat( + jsonld['datePublished'].replace('Z', '+00:00') + ) + if pub_date > recent_cutoff: + recent_articles.append(url) + break + except: + continue + + print(f"Found {len(recent_articles)} recent articles") +``` + +### BM25 Relevance Scoring + +```python +async def relevance_scoring(): + async with AsyncUrlSeeder() as seeder: + # Find pages about Python async programming + config = SeedingConfig( + source="sitemap", + extract_head=True, # Required for content-based scoring + query="python async await concurrency", + scoring_method="bm25", + score_threshold=0.3, # Only 30%+ relevant pages + max_urls=20 + ) + + urls = await seeder.urls("docs.python.org", config) + + # Results are automatically sorted by relevance + print("Most relevant Python async content:") + for url in urls[:5]: + score = url['relevance_score'] + title = url['head_data'].get('title', 'No title') + print(f"[{score:.2f}] {title}") + print(f" {url['url']}") + +# URL-based scoring (when extract_head=False) +async def url_based_scoring(): + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + extract_head=False, # Fast URL-only scoring + query="machine learning tutorial", + scoring_method="bm25", + score_threshold=0.2 + ) + + urls = await seeder.urls("example.com", config) + + # Scoring based on URL structure, domain, path segments + for url in urls[:5]: + print(f"[{url['relevance_score']:.2f}] {url['url']}") + +# Multi-concept queries +async def complex_queries(): + queries = [ + "data science pandas numpy visualization", + "web scraping automation selenium", + "machine learning tensorflow pytorch", + "api documentation rest graphql" + ] + + async with AsyncUrlSeeder() as seeder: + all_results = [] + + for query in queries: + config = SeedingConfig( + source="sitemap", + extract_head=True, + query=query, + scoring_method="bm25", + score_threshold=0.4, + max_urls=10 + ) + + urls = await seeder.urls("learning-site.com", config) + all_results.extend(urls) + + # Remove duplicates while preserving order + seen = set() + unique_results = [] + for url in all_results: + if url['url'] not in seen: + seen.add(url['url']) + unique_results.append(url) + + print(f"Found {len(unique_results)} unique pages across all topics") +``` + +### Live URL Validation + +```python +async def url_validation(): + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + live_check=True, # Verify URLs are accessible + concurrency=15, # Parallel HEAD requests + hits_per_sec=8, # Rate limiting + max_urls=100 + ) + + urls = await seeder.urls("example.com", config) + + # Analyze results + valid_urls = [u for u in urls if u['status'] == 'valid'] + invalid_urls = [u for u in urls if u['status'] == 'not_valid'] + + print(f"✅ Valid URLs: {len(valid_urls)}") + print(f"❌ Invalid URLs: {len(invalid_urls)}") + print(f"📊 Success rate: {len(valid_urls)/len(urls)*100:.1f}%") + + # Show some invalid URLs for debugging + if invalid_urls: + print("\nSample invalid URLs:") + for url in invalid_urls[:3]: + print(f" - {url['url']}") + +# Combined validation and metadata +async def comprehensive_validation(): + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + live_check=True, # Verify accessibility + extract_head=True, # Get metadata + query="tutorial guide", # Relevance scoring + scoring_method="bm25", + score_threshold=0.2, + concurrency=10, + max_urls=50 + ) + + urls = await seeder.urls("docs.example.com", config) + + # Filter for valid, relevant tutorials + good_tutorials = [ + url for url in urls + if url['status'] == 'valid' and + url['relevance_score'] > 0.3 and + 'tutorial' in url['head_data'].get('title', '').lower() + ] + + print(f"Found {len(good_tutorials)} high-quality tutorials") +``` + +### Multi-Domain Discovery + +```python +async def multi_domain_research(): + async with AsyncUrlSeeder() as seeder: + # Research Python tutorials across multiple sites + domains = [ + "docs.python.org", + "realpython.com", + "python-course.eu", + "tutorialspoint.com" + ] + + config = SeedingConfig( + source="sitemap", + extract_head=True, + query="python beginner tutorial basics", + scoring_method="bm25", + score_threshold=0.3, + max_urls=15 # Per domain + ) + + # Discover across all domains in parallel + results = await seeder.many_urls(domains, config) + + # Collect and rank all tutorials + all_tutorials = [] + for domain, urls in results.items(): + for url in urls: + url['domain'] = domain + all_tutorials.append(url) + + # Sort by relevance across all domains + all_tutorials.sort(key=lambda x: x['relevance_score'], reverse=True) + + print(f"Top 10 Python tutorials across {len(domains)} sites:") + for i, tutorial in enumerate(all_tutorials[:10], 1): + score = tutorial['relevance_score'] + title = tutorial['head_data'].get('title', 'No title')[:60] + domain = tutorial['domain'] + print(f"{i:2d}. [{score:.2f}] {title}") + print(f" {domain}") + +# Competitor analysis +async def competitor_analysis(): + competitors = ["competitor1.com", "competitor2.com", "competitor3.com"] + + async with AsyncUrlSeeder() as seeder: + config = SeedingConfig( + source="sitemap", + extract_head=True, + pattern="*/blog/*", + max_urls=50 + ) + + results = await seeder.many_urls(competitors, config) + + # Analyze content strategies + for domain, urls in results.items(): + content_types = {} + + for url in urls: + # Extract content type from metadata + meta = url['head_data'].get('meta', {}) + og_type = meta.get('og:type', 'unknown') + content_types[og_type] = content_types.get(og_type, 0) + 1 + + print(f"\n{domain} content distribution:") + for ctype, count in sorted(content_types.items(), + key=lambda x: x[1], reverse=True): + print(f" {ctype}: {count}") +``` + +### Complete Pipeline: Discovery → Filter → Crawl + +```python +async def smart_research_pipeline(): + """Complete pipeline: discover URLs, filter by relevance, crawl top results""" + + async with AsyncUrlSeeder() as seeder: + # Step 1: Discover relevant URLs + print("🔍 Discovering URLs...") + config = SeedingConfig( + source="sitemap+cc", + extract_head=True, + query="machine learning deep learning tutorial", + scoring_method="bm25", + score_threshold=0.4, + max_urls=100 + ) + + urls = await seeder.urls("example.com", config) + print(f" Found {len(urls)} relevant URLs") + + # Step 2: Select top articles + top_articles = sorted(urls, + key=lambda x: x['relevance_score'], + reverse=True)[:10] + + print(f" Selected top {len(top_articles)} for crawling") + + # Step 3: Show what we're about to crawl + print("\n📋 Articles to crawl:") + for i, article in enumerate(top_articles, 1): + score = article['relevance_score'] + title = article['head_data'].get('title', 'No title')[:60] + print(f" {i}. [{score:.2f}] {title}") + + # Step 4: Crawl selected articles + from crawl4ai import AsyncWebCrawler, CrawlerRunConfig + + print(f"\n🕷️ Crawling {len(top_articles)} articles...") + + async with AsyncWebCrawler() as crawler: + config = CrawlerRunConfig( + only_text=True, + word_count_threshold=200, + stream=True # Process results as they come + ) + + # Extract URLs and crawl + article_urls = [article['url'] for article in top_articles] + + crawled_count = 0 + async for result in await crawler.arun_many(article_urls, config=config): + if result.success: + crawled_count += 1 + word_count = len(result.markdown.raw_markdown.split()) + print(f" ✅ [{crawled_count}/{len(article_urls)}] " + f"{word_count} words from {result.url[:50]}...") + else: + print(f" ❌ Failed: {result.url[:50]}...") + + print(f"\n✨ Successfully crawled {crawled_count} articles!") + +asyncio.run(smart_research_pipeline()) +``` + +### Advanced Features and Performance + +```python +# Cache management +async def cache_management(): + async with AsyncUrlSeeder() as seeder: + # First run - populate cache + config = SeedingConfig( + source="sitemap", + extract_head=True, + force=True # Bypass cache, fetch fresh + ) + urls = await seeder.urls("example.com", config) + + # Subsequent runs - use cache (much faster) + config = SeedingConfig( + source="sitemap", + extract_head=True, + force=False # Use cache + ) + urls = await seeder.urls("example.com", config) + +# Performance optimization +async def performance_tuning(): + async with AsyncUrlSeeder() as seeder: + # High-performance configuration + config = SeedingConfig( + source="cc", + concurrency=50, # Many parallel workers + hits_per_sec=20, # High rate limit + max_urls=10000, # Large dataset + extract_head=False, # Skip metadata for speed + filter_nonsense_urls=True # Auto-filter utility URLs + ) + + import time + start = time.time() + urls = await seeder.urls("large-site.com", config) + elapsed = time.time() - start + + print(f"Processed {len(urls)} URLs in {elapsed:.2f}s") + print(f"Speed: {len(urls)/elapsed:.0f} URLs/second") + +# Memory-safe processing for large domains +async def large_domain_processing(): + async with AsyncUrlSeeder() as seeder: + # Safe for domains with 1M+ URLs + config = SeedingConfig( + source="cc+sitemap", + concurrency=50, # Bounded queue adapts to this + max_urls=100000, # Process in batches + filter_nonsense_urls=True + ) + + # The seeder automatically manages memory by: + # - Using bounded queues (prevents RAM spikes) + # - Applying backpressure when queue is full + # - Processing URLs as they're discovered + urls = await seeder.urls("huge-site.com", config) + +# Configuration cloning and reuse +config_base = SeedingConfig( + source="sitemap", + extract_head=True, + concurrency=20 +) + +# Create variations +blog_config = config_base.clone(pattern="*/blog/*") +docs_config = config_base.clone( + pattern="*/docs/*", + query="API documentation", + scoring_method="bm25" +) +fast_config = config_base.clone( + extract_head=False, + concurrency=100, + hits_per_sec=50 +) +``` + +### Troubleshooting and Best Practices + +```python +# Common issues and solutions +async def troubleshooting_guide(): + async with AsyncUrlSeeder() as seeder: + # Issue: No URLs found + try: + config = SeedingConfig(source="sitemap", pattern="*/nonexistent/*") + urls = await seeder.urls("example.com", config) + if not urls: + # Solution: Try broader pattern or different source + config = SeedingConfig(source="cc+sitemap", pattern="*") + urls = await seeder.urls("example.com", config) + except Exception as e: + print(f"Discovery failed: {e}") + + # Issue: Slow performance + config = SeedingConfig( + source="sitemap", # Faster than CC + concurrency=10, # Reduce if hitting rate limits + hits_per_sec=5, # Add rate limiting + extract_head=False # Skip if metadata not needed + ) + + # Issue: Low relevance scores + config = SeedingConfig( + query="specific detailed query terms", + score_threshold=0.1, # Lower threshold + scoring_method="bm25" + ) + + # Issue: Memory issues with large sites + config = SeedingConfig( + max_urls=10000, # Limit results + concurrency=20, # Reduce concurrency + source="sitemap" # Use sitemap only + ) + +# Performance benchmarks +print(""" +Typical performance on standard connection: +- Sitemap discovery: 100-1,000 URLs/second +- Common Crawl discovery: 50-500 URLs/second +- HEAD checking: 10-50 URLs/second +- Head extraction: 5-20 URLs/second +- BM25 scoring: 10,000+ URLs/second +""") + +# Best practices +best_practices = """ +✅ Use context manager: async with AsyncUrlSeeder() as seeder +✅ Start with sitemaps (faster), add CC if needed +✅ Use extract_head=True only when you need metadata +✅ Set reasonable max_urls to limit processing +✅ Add rate limiting for respectful crawling +✅ Cache results with force=False for repeated operations +✅ Filter nonsense URLs (enabled by default) +✅ Use specific patterns to reduce irrelevant results +""" +``` + +**📖 Learn more:** [Complete URL Seeding Guide](https://docs.crawl4ai.com/core/url-seeding/), [SeedingConfig Reference](https://docs.crawl4ai.com/api/parameters/), [Multi-URL Crawling](https://docs.crawl4ai.com/advanced/multi-url-crawling/) \ No newline at end of file diff --git a/docs/md_v2/assets/llmtxt/crawl4ai_all_examples_content.llm.txt b/docs/md_v2/assets/llmtxt/crawl4ai_all_examples_content.llm.txt deleted file mode 100644 index 22f3dc31..00000000 --- a/docs/md_v2/assets/llmtxt/crawl4ai_all_examples_content.llm.txt +++ /dev/null @@ -1,13263 +0,0 @@ -# Code Concatenation - -Generated on 2025-05-24 - -## File: docs/examples/docker/demo_docker_api.py - -```py -import asyncio -import httpx -import json -import os -import time -from typing import List, Dict, Any, AsyncGenerator, Optional -import textwrap # ← new: for pretty code literals -import urllib.parse # ← needed for URL-safe /llm calls -from dotenv import load_dotenv -from rich.console import Console -from rich.syntax import Syntax -from rich.panel import Panel -from rich.table import Table - -# --- Setup & Configuration --- -load_dotenv() # Load environment variables from .env file - -console = Console() - -# --- Configuration --- -BASE_URL = os.getenv("CRAWL4AI_TEST_URL", "http://localhost:8020") -BASE_URL = os.getenv("CRAWL4AI_TEST_URL", "http://localhost:11235") -# Target URLs -SIMPLE_URL = "https://example.com" # For demo purposes -SIMPLE_URL = "https://httpbin.org/html" -LINKS_URL = "https://httpbin.org/links/10/0" -FORMS_URL = "https://httpbin.org/forms/post" # For JS demo -BOOKS_URL = "http://books.toscrape.com/" # For CSS extraction -PYTHON_URL = "https://python.org" # For deeper crawl -# Use the same sample site as deep crawl tests for consistency -DEEP_CRAWL_BASE_URL = os.getenv( - "DEEP_CRAWL_TEST_SITE", "https://docs.crawl4ai.com/samples/deepcrawl/") -DEEP_CRAWL_DOMAIN = "docs.crawl4ai.com" - -# --- Helper Functions --- - - -async def check_server_health(client: httpx.AsyncClient): - """Check if the server is healthy before running tests.""" - console.print("[bold cyan]Checking server health...[/]", end="") - try: - response = await client.get("/health", timeout=10.0) - response.raise_for_status() - health_data = response.json() - console.print( - f"[bold green] Server OK! Version: {health_data.get('version', 'N/A')}[/]") - return True - except (httpx.RequestError, httpx.HTTPStatusError) as e: - console.print(f"\n[bold red]Server health check FAILED:[/]") - console.print(f"Error: {e}") - console.print(f"Is the server running at {BASE_URL}?") - return False - except Exception as e: - console.print( - f"\n[bold red]An unexpected error occurred during health check:[/]") - console.print(e) - return False - - -def print_payload(payload: Dict[str, Any]): - """Prints the JSON payload nicely with a dark theme.""" - syntax = Syntax( - json.dumps(payload, indent=2), - "json", - theme="monokai", # <--- Changed theme here - line_numbers=False, - word_wrap=True # Added word wrap for potentially long payloads - ) - console.print(Panel(syntax, title="Request Payload", - border_style="blue", expand=False)) - - -def print_result_summary(results: List[Dict[str, Any]], title: str = "Crawl Results Summary", max_items: int = 3): - """Prints a concise summary of crawl results.""" - if not results: - console.print(f"[yellow]{title}: No results received.[/]") - return - - console.print(Panel(f"[bold]{title}[/]", - border_style="green", expand=False)) - count = 0 - for result in results: - if count >= max_items: - console.print( - f"... (showing first {max_items} of {len(results)} results)") - break - count += 1 - success_icon = "[green]✔[/]" if result.get('success') else "[red]✘[/]" - url = result.get('url', 'N/A') - status = result.get('status_code', 'N/A') - content_info = "" - if result.get('extracted_content'): - content_str = json.dumps(result['extracted_content']) - snippet = ( - content_str[:70] + '...') if len(content_str) > 70 else content_str - content_info = f" | Extracted: [cyan]{snippet}[/]" - elif result.get('markdown'): - content_info = f" | Markdown: [cyan]Present[/]" - elif result.get('html'): - content_info = f" | HTML Size: [cyan]{len(result['html'])}[/]" - - console.print( - f"{success_icon} URL: [link={url}]{url}[/link] (Status: {status}){content_info}") - if "metadata" in result and "depth" in result["metadata"]: - console.print(f" Depth: {result['metadata']['depth']}") - if not result.get('success') and result.get('error_message'): - console.print(f" [red]Error: {result['error_message']}[/]") - - -async def make_request(client: httpx.AsyncClient, endpoint: str, payload: Dict[str, Any], title: str) -> Optional[List[Dict[str, Any]]]: - """Handles non-streaming POST requests.""" - console.rule(f"[bold blue]{title}[/]", style="blue") - print_payload(payload) - console.print(f"Sending POST request to {client.base_url}{endpoint}...") - try: - start_time = time.time() - response = await client.post(endpoint, json=payload) - duration = time.time() - start_time - console.print( - f"Response Status: [bold {'green' if response.is_success else 'red'}]{response.status_code}[/] (took {duration:.2f}s)") - response.raise_for_status() - data = response.json() - if data.get("success"): - results = data.get("results", []) - print_result_summary(results, title=f"{title} Results") - return results - else: - console.print("[bold red]Request reported failure:[/]") - console.print(data) - return None - except httpx.HTTPStatusError as e: - console.print(f"[bold red]HTTP Error:[/]") - console.print(f"Status: {e.response.status_code}") - try: - console.print(Panel(Syntax(json.dumps( - e.response.json(), indent=2), "json", theme="default"), title="Error Response")) - except json.JSONDecodeError: - console.print(f"Response Body: {e.response.text}") - except httpx.RequestError as e: - console.print(f"[bold red]Request Error: {e}[/]") - except Exception as e: - console.print(f"[bold red]Unexpected Error: {e}[/]") - return None - - -async def stream_request(client: httpx.AsyncClient, endpoint: str, payload: Dict[str, Any], title: str): - """Handles streaming POST requests.""" - console.rule(f"[bold magenta]{title}[/]", style="magenta") - print_payload(payload) - console.print( - f"Sending POST stream request to {client.base_url}{endpoint}...") - all_results = [] - initial_status_code = None # Store initial status code - - try: - start_time = time.time() - async with client.stream("POST", endpoint, json=payload) as response: - initial_status_code = response.status_code # Capture initial status - duration = time.time() - start_time # Time to first byte potentially - console.print( - f"Initial Response Status: [bold {'green' if response.is_success else 'red'}]{initial_status_code}[/] (first byte ~{duration:.2f}s)") - response.raise_for_status() # Raise exception for bad *initial* status codes - - console.print("[magenta]--- Streaming Results ---[/]") - completed = False - async for line in response.aiter_lines(): - if line: - try: - data = json.loads(line) - if data.get("status") == "completed": - completed = True - console.print( - "[bold green]--- Stream Completed ---[/]") - break - elif data.get("url"): # Looks like a result dictionary - all_results.append(data) - # Display summary info as it arrives - success_icon = "[green]✔[/]" if data.get( - 'success') else "[red]✘[/]" - url = data.get('url', 'N/A') - # Display status code FROM THE RESULT DATA if available - result_status = data.get('status_code', 'N/A') - console.print( - f" {success_icon} Received: [link={url}]{url}[/link] (Status: {result_status})") - if not data.get('success') and data.get('error_message'): - console.print( - f" [red]Error: {data['error_message']}[/]") - else: - console.print( - f" [yellow]Stream meta-data:[/yellow] {data}") - except json.JSONDecodeError: - console.print( - f" [red]Stream decode error for line:[/red] {line}") - if not completed: - console.print( - "[bold yellow]Warning: Stream ended without 'completed' marker.[/]") - - except httpx.HTTPStatusError as e: - # Use the captured initial status code if available, otherwise from the exception - status = initial_status_code if initial_status_code is not None else e.response.status_code - console.print(f"[bold red]HTTP Error (Initial Request):[/]") - console.print(f"Status: {status}") - try: - console.print(Panel(Syntax(json.dumps( - e.response.json(), indent=2), "json", theme="default"), title="Error Response")) - except json.JSONDecodeError: - console.print(f"Response Body: {e.response.text}") - except httpx.RequestError as e: - console.print(f"[bold red]Request Error: {e}[/]") - except Exception as e: - console.print(f"[bold red]Unexpected Error during streaming: {e}[/]") - # Print stack trace for unexpected errors - console.print_exception(show_locals=False) - - # Call print_result_summary with the *collected* results AFTER the stream is done - print_result_summary(all_results, title=f"{title} Collected Results") - - -def load_proxies_from_env() -> List[Dict]: - """ - Load proxies from the PROXIES environment variable. - Expected format: IP:PORT:USER:PASS,IP:PORT,IP2:PORT2:USER2:PASS2,... - Returns a list of dictionaries suitable for the 'params' of ProxyConfig. - """ - proxies_params_list = [] - proxies_str = os.getenv("PROXIES", "") - if not proxies_str: - # console.print("[yellow]PROXIES environment variable not set or empty.[/]") - return proxies_params_list # Return empty list if not set - - try: - proxy_entries = proxies_str.split(",") - for entry in proxy_entries: - entry = entry.strip() - if not entry: - continue - - parts = entry.split(":") - proxy_dict = {} - - if len(parts) == 4: # Format: IP:PORT:USER:PASS - ip, port, username, password = parts - proxy_dict = { - "server": f"http://{ip}:{port}", # Assuming http protocol - "username": username, - "password": password, - # "ip": ip # 'ip' is not a standard ProxyConfig param, 'server' contains it - } - elif len(parts) == 2: # Format: IP:PORT - ip, port = parts - proxy_dict = { - "server": f"http://{ip}:{port}", - # "ip": ip - } - else: - console.print( - f"[yellow]Skipping invalid proxy string format:[/yellow] {entry}") - continue - - proxies_params_list.append(proxy_dict) - - except Exception as e: - console.print( - f"[red]Error loading proxies from environment:[/red] {e}") - - if proxies_params_list: - console.print( - f"[cyan]Loaded {len(proxies_params_list)} proxies from environment.[/]") - # else: - # console.print("[yellow]No valid proxies loaded from environment.[/]") - - return proxies_params_list - - -# --- Demo Functions --- - -# 1. Basic Crawling -async def demo_basic_single_url(client: httpx.AsyncClient): - payload = { - "urls": [SIMPLE_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "cache_mode": "BYPASS" - } - } - } - result = await make_request(client, "/crawl", payload, "Demo 1a: Basic Single URL Crawl") - return result - - -async def demo_basic_multi_url(client: httpx.AsyncClient): - payload = { - "urls": [SIMPLE_URL, LINKS_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": {"type": "CrawlerRunConfig", "params": {"cache_mode": "BYPASS"}} - } - result = await make_request(client, "/crawl", payload, "Demo 1b: Basic Multi URL Crawl") - return result - - -async def demo_streaming_multi_url(client: httpx.AsyncClient): - payload = { - # "urls": [SIMPLE_URL, LINKS_URL, FORMS_URL, SIMPLE_URL, LINKS_URL, FORMS_URL], # Add another URL - "urls": [ - "https://example.com/page1", - "https://example.com/page2", - "https://example.com/page3", - "https://example.com/page4", - "https://example.com/page5" - ], # Add another URL - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "stream": True, - } - } - } - result = await stream_request(client, "/crawl/stream", payload, "Demo 1c: Streaming Multi URL Crawl") - return result - -# 2. Markdown Generation & Content Filtering - - -async def demo_markdown_default(client: httpx.AsyncClient): - payload = { - "urls": [SIMPLE_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "markdown_generator": { - "type": "DefaultMarkdownGenerator", - "params": { - "content_source": "fit_html", - "options": { - "type": "dict", - "value": { - "ignore_links": True - } - } - } - } # Explicitly default - } - } - } - result = await make_request(client, "/crawl", payload, "Demo 2a: Default Markdown Generation") - return result - - -async def demo_markdown_pruning(client: httpx.AsyncClient): - payload = { - "urls": [PYTHON_URL], # Use a more complex page - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "cache_mode": "BYPASS", - "markdown_generator": { - "type": "DefaultMarkdownGenerator", - "params": { - "content_filter": { - "type": "PruningContentFilter", - "params": { - "threshold": 0.6, - "threshold_type": "relative" - } - } - } - } - } - } - } - result = await make_request(client, "/crawl", payload, "Demo 2b: Markdown with Pruning Filter") - return result - - -async def demo_markdown_bm25(client: httpx.AsyncClient): - payload = { - "urls": [PYTHON_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "cache_mode": "BYPASS", - "markdown_generator": { - "type": "DefaultMarkdownGenerator", - "params": { - "content_filter": { - "type": "BM25ContentFilter", - "params": { - "user_query": "Python documentation language reference" - } - } - } - } - } - } - } - result = await make_request(client, "/crawl", payload, "Demo 2c: Markdown with BM25 Filter") - return result - -# 3. Specific Parameters -# Corrected Demo Function: demo_param_css_selector - - -async def demo_param_css_selector(client: httpx.AsyncClient): - css_selector = ".main-content" # Using the suggested correct selector - payload = { - "urls": [PYTHON_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "css_selector": css_selector # Target specific div - # No extraction strategy is needed to demo this parameter's effect on input HTML - } - } - } - results = await make_request(client, "/crawl", payload, f"Demo 3a: Using css_selector ('{css_selector}')") - - if results: - result = results[0] - if result['success'] and result.get('html'): - # Check if the returned HTML is likely constrained - # A simple check: does it contain expected content from within the selector, - # and does it LACK content known to be outside (like footer links)? - html_content = result['html'] - # Text likely within .main-content somewhere - content_present = 'Python Software Foundation' in html_content - # Text likely in the footer, outside .main-content - footer_absent = 'Legal Statements' not in html_content - - console.print( - f" Content Check: Text inside '{css_selector}' likely present? {'[green]Yes[/]' if content_present else '[red]No[/]'}") - console.print( - f" Content Check: Text outside '{css_selector}' (footer) likely absent? {'[green]Yes[/]' if footer_absent else '[red]No[/]'}") - - if not content_present or not footer_absent: - console.print( - f" [yellow]Note:[/yellow] HTML filtering might not be precise or page structure changed. Result HTML length: {len(html_content)}") - else: - console.print( - f" [green]Verified:[/green] Returned HTML appears limited by css_selector. Result HTML length: {len(html_content)}") - - elif result['success']: - console.print( - "[yellow]HTML content was empty in the successful result.[/]") - # Error message is handled by print_result_summary called by make_request - - -async def demo_param_js_execution(client: httpx.AsyncClient): - payload = { - "urls": ["https://example.com"], # Use a page with a form - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "cache_mode": "BYPASS", - # Simple JS to fill and maybe click (won't submit without more complex setup) - "js_code": """ - (() => { - document.querySelector('h1').innerText = 'Crawl4AI Demo'; - return { filled_name: document.querySelector('h1').innerText }; - })(); - """, - "delay_before_return_html": 0.5 # Give JS time to potentially run - } - } - } - results = await make_request(client, "/crawl", payload, "Demo 3b: Using js_code Parameter") - if results and results[0].get("js_execution_result"): - console.print("[cyan]JS Execution Result:[/]", - results[0]["js_execution_result"]) - elif results: - console.print("[yellow]JS Execution Result not found in response.[/]") - - -async def demo_param_screenshot(client: httpx.AsyncClient): - payload = { - "urls": [SIMPLE_URL], - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": {"cache_mode": "BYPASS", "screenshot": True} - } - } - results = await make_request(client, "/crawl", payload, "Demo 3c: Taking a Screenshot") - if results and results[0].get("screenshot"): - console.print( - f"[cyan]Screenshot data received (length):[/] {len(results[0]['screenshot'])}") - elif results: - console.print("[yellow]Screenshot data not found in response.[/]") - - -async def demo_param_ssl_fetch(client: httpx.AsyncClient): - payload = { - "urls": [PYTHON_URL], # Needs HTTPS - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": {"cache_mode": "BYPASS", "fetch_ssl_certificate": True} - } - } - results = await make_request(client, "/crawl", payload, "Demo 3d: Fetching SSL Certificate") - if results and results[0].get("ssl_certificate"): - console.print("[cyan]SSL Certificate Info:[/]") - console.print(results[0]["ssl_certificate"]) - elif results: - console.print("[yellow]SSL Certificate data not found in response.[/]") - - -async def demo_param_proxy(client: httpx.AsyncClient): - proxy_params_list = load_proxies_from_env() # Get the list of parameter dicts - if not proxy_params_list: - console.rule( - "[bold yellow]Demo 3e: Using Proxies (SKIPPED)[/]", style="yellow") - console.print("Set the PROXIES environment variable to run this demo.") - console.print("Format: IP:PORT:USR:PWD,IP:PORT,...") - return - - payload = { - "urls": ["https://httpbin.org/ip"], # URL that shows originating IP - "browser_config": {"type": "BrowserConfig", "params": {"headless": True}}, - "crawler_config": { - "type": "CrawlerRunConfig", - "params": { - "cache_mode": "BYPASS", - "proxy_rotation_strategy": { - "type": "RoundRobinProxyStrategy", - "params": { - "proxies": [ - # [ - # { - # "type": "ProxyConfig", - # "params": { - # server:"...", - # "username": "...", - # "password": "..." - # } - # }, - # ... - # ] - - # Filter out the 'ip' key when sending to server, as it's not part of ProxyConfig - {"type": "ProxyConfig", "params": { - k: v for k, v in p.items() if k != 'ip'}} - for p in proxy_params_list - ] - } - } - } - } - } - results = await make_request(client, "/crawl", payload, "Demo 3e: Using Proxies") - - # --- Verification Logic --- - if results and results[0].get("success"): - result = results[0] - try: - # httpbin.org/ip returns JSON within the HTML body's tag
- html_content = result.get('html', '')
- # Basic extraction - find JSON within tags or just the JSON itself
- json_str = None
- if ' 500 else md
- console.print(Panel(snippet, title="Markdown snippet",
- border_style="cyan", expand=False))
- except Exception as e:
- console.print(f"[bold red]Error hitting /md:[/] {e}")
-
-# 8. LLM QA helper endpoint
-
-
-async def demo_llm_endpoint(client: httpx.AsyncClient):
- """
- Quick QA round-trip with /llm.
- Asks a trivial question against SIMPLE_URL just to show wiring.
- """
- page_url = SIMPLE_URL
- question = "What is the title of this page?"
-
- console.rule("[bold magenta]Demo 7b: /llm Endpoint[/]", style="magenta")
- enc = urllib.parse.quote_plus(page_url, safe="")
- console.print(f"GET /llm/{enc}?q={question}")
-
- try:
- t0 = time.time()
- resp = await client.get(f"/llm/{enc}", params={"q": question})
- dt = time.time() - t0
- console.print(
- f"Response Status: [bold {'green' if resp.is_success else 'red'}]{resp.status_code}[/] (took {dt:.2f}s)")
- resp.raise_for_status()
- answer = resp.json().get("answer", "")
- console.print(Panel(answer or "No answer returned",
- title="LLM answer", border_style="magenta", expand=False))
- except Exception as e:
- console.print(f"[bold red]Error hitting /llm:[/] {e}")
-
-
-# 9. /config/dump helpers --------------------------------------------------
-
-async def demo_config_dump_valid(client: httpx.AsyncClient):
- """
- Send a single top-level CrawlerRunConfig(...) expression and show the dump.
- """
- code_snippet = "CrawlerRunConfig(cache_mode='BYPASS', screenshot=True)"
- payload = {"code": code_snippet}
-
- console.rule("[bold blue]Demo 8a: /config/dump (valid)[/]", style="blue")
- print_payload(payload)
-
- try:
- t0 = time.time()
- resp = await client.post("/config/dump", json=payload)
- dt = time.time() - t0
- console.print(
- f"Response Status: [bold {'green' if resp.is_success else 'red'}]{resp.status_code}[/] (took {dt:.2f}s)")
- resp.raise_for_status()
- dump_json = resp.json()
- console.print(Panel(Syntax(json.dumps(dump_json, indent=2),
- "json", theme="monokai"), title="Dump()", border_style="cyan"))
- except Exception as e:
- console.print(f"[bold red]Error in valid /config/dump call:[/] {e}")
-
-
-async def demo_config_dump_invalid(client: httpx.AsyncClient):
- """
- Purposely break the rule (nested call) to show the 400 parse error.
- """
- bad_code = textwrap.dedent("""
- BrowserConfig(headless=True); CrawlerRunConfig()
- """).strip()
- payload = {"code": bad_code}
-
- console.rule(
- "[bold magenta]Demo 8b: /config/dump (invalid)[/]", style="magenta")
- print_payload(payload)
-
- try:
- resp = await client.post("/config/dump", json=payload)
- console.print(
- f"Response Status: [bold {'green' if resp.is_success else 'red'}]{resp.status_code}[/]")
- resp.raise_for_status() # should throw -> except
- except httpx.HTTPStatusError as e:
- console.print("[cyan]Expected parse/validation failure captured:[/]")
- try:
- console.print(Panel(Syntax(json.dumps(
- e.response.json(), indent=2), "json", theme="fruity"), title="Error payload"))
- except Exception:
- console.print(e.response.text)
- except Exception as e:
- console.print(
- f"[bold red]Unexpected error during invalid test:[/] {e}")
-
-
-# --- Update Main Runner to include new demo ---
-async def main_demo():
- async with httpx.AsyncClient(base_url=BASE_URL, timeout=300.0) as client:
- if not await check_server_health(client):
- return
-
- # --- Run Demos ---
- # await demo_basic_single_url(client)
- # await demo_basic_multi_url(client)
- # await demo_streaming_multi_url(client)
-
- # await demo_markdown_default(client)
- # await demo_markdown_pruning(client)
- # await demo_markdown_bm25(client)
-
- # await demo_param_css_selector(client)
- # await demo_param_js_execution(client)
- # await demo_param_screenshot(client)
- # await demo_param_ssl_fetch(client)
- # await demo_param_proxy(client) # Skips if no PROXIES env var
-
- # await demo_extract_css(client)
- # await demo_extract_llm(client) # Skips if no common LLM key env var
-
- # await demo_deep_basic(client)
- # await demo_deep_streaming(client) # This need extra work
-
- # await demo_deep_with_css_extraction(client)
- # # Skips if no common LLM key env var
- # await demo_deep_with_llm_extraction(client)
- # await demo_deep_with_proxy(client) # Skips if no PROXIES env var
- # await demo_deep_with_ssl(client) # Added the new demo
-
- # --- Helper endpoints ---
- await demo_markdown_endpoint(client)
- await demo_llm_endpoint(client)
-
- # --- /config/dump sanity checks ---
- await demo_config_dump_valid(client)
- await demo_config_dump_invalid(client)
-
- console.rule("[bold green]Demo Complete[/]", style="green")
-
-
-if __name__ == "__main__":
- try:
- asyncio.run(main_demo())
- except KeyboardInterrupt:
- console.print("\n[yellow]Demo interrupted by user.[/]")
- except Exception as e:
- console.print(
- f"\n[bold red]An error occurred during demo execution:[/]")
- console.print_exception(show_locals=False)
-
-```
-
-
-## File: docs/examples/docker/demo_docker_polling.py
-
-```py
-
-#!/usr/bin/env python3
-"""
-demo_docker_polling.py
-Quick sanity-check for the asynchronous crawl job endpoints:
-
- • POST /crawl/job – enqueue work, get task_id
- • GET /crawl/job/{id} – poll status / fetch result
-
-The style matches demo_docker_api.py (console.rule banners, helper
-functions, coloured status lines). Adjust BASE_URL as needed.
-
-Run: python demo_docker_polling.py
-"""
-
-import asyncio, json, os, time, urllib.parse
-from typing import Dict, List
-
-import httpx
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
-
-console = Console()
-BASE_URL = os.getenv("BASE_URL", "http://localhost:11234")
-SIMPLE_URL = "https://example.org"
-LINKS_URL = "https://httpbin.org/links/10/1"
-
-# --- helpers --------------------------------------------------------------
-
-
-def print_payload(payload: Dict):
- console.print(Panel(Syntax(json.dumps(payload, indent=2),
- "json", theme="monokai", line_numbers=False),
- title="Payload", border_style="cyan", expand=False))
-
-
-async def check_server_health(client: httpx.AsyncClient) -> bool:
- try:
- resp = await client.get("/health")
- if resp.is_success:
- console.print("[green]Server healthy[/]")
- return True
- except Exception:
- pass
- console.print("[bold red]Server is not responding on /health[/]")
- return False
-
-
-async def poll_for_result(client: httpx.AsyncClient, task_id: str,
- poll_interval: float = 1.5, timeout: float = 90.0):
- """Hit /crawl/job/{id} until COMPLETED/FAILED or timeout."""
- start = time.time()
- while True:
- resp = await client.get(f"/crawl/job/{task_id}")
- resp.raise_for_status()
- data = resp.json()
- status = data.get("status")
- if status.upper() in ("COMPLETED", "FAILED"):
- return data
- if time.time() - start > timeout:
- raise TimeoutError(f"Task {task_id} did not finish in {timeout}s")
- await asyncio.sleep(poll_interval)
-
-
-# --- demo functions -------------------------------------------------------
-
-
-async def demo_poll_single_url(client: httpx.AsyncClient):
- payload = {
- "urls": [SIMPLE_URL],
- "browser_config": {"type": "BrowserConfig",
- "params": {"headless": True}},
- "crawler_config": {"type": "CrawlerRunConfig",
- "params": {"cache_mode": "BYPASS"}}
- }
-
- console.rule("[bold blue]Demo A: /crawl/job Single URL[/]", style="blue")
- print_payload(payload)
-
- # enqueue
- resp = await client.post("/crawl/job", json=payload)
- console.print(f"Enqueue status: [bold]{resp.status_code}[/]")
- resp.raise_for_status()
- task_id = resp.json()["task_id"]
- console.print(f"Task ID: [yellow]{task_id}[/]")
-
- # poll
- console.print("Polling…")
- result = await poll_for_result(client, task_id)
- console.print(Panel(Syntax(json.dumps(result, indent=2),
- "json", theme="fruity"),
- title="Final result", border_style="green"))
- if result["status"] == "COMPLETED":
- console.print("[green]✅ Crawl succeeded[/]")
- else:
- console.print("[red]❌ Crawl failed[/]")
-
-
-async def demo_poll_multi_url(client: httpx.AsyncClient):
- payload = {
- "urls": [SIMPLE_URL, LINKS_URL],
- "browser_config": {"type": "BrowserConfig",
- "params": {"headless": True}},
- "crawler_config": {"type": "CrawlerRunConfig",
- "params": {"cache_mode": "BYPASS"}}
- }
-
- console.rule("[bold magenta]Demo B: /crawl/job Multi-URL[/]",
- style="magenta")
- print_payload(payload)
-
- resp = await client.post("/crawl/job", json=payload)
- console.print(f"Enqueue status: [bold]{resp.status_code}[/]")
- resp.raise_for_status()
- task_id = resp.json()["task_id"]
- console.print(f"Task ID: [yellow]{task_id}[/]")
-
- console.print("Polling…")
- result = await poll_for_result(client, task_id)
- console.print(Panel(Syntax(json.dumps(result, indent=2),
- "json", theme="fruity"),
- title="Final result", border_style="green"))
- if result["status"] == "COMPLETED":
- console.print(
- f"[green]✅ {len(json.loads(result['result'])['results'])} URLs crawled[/]")
- else:
- console.print("[red]❌ Crawl failed[/]")
-
-
-# --- main runner ----------------------------------------------------------
-
-
-async def main_demo():
- async with httpx.AsyncClient(base_url=BASE_URL, timeout=300.0) as client:
- if not await check_server_health(client):
- return
- await demo_poll_single_url(client)
- await demo_poll_multi_url(client)
- console.rule("[bold green]Polling demos complete[/]", style="green")
-
-
-if __name__ == "__main__":
- try:
- asyncio.run(main_demo())
- except KeyboardInterrupt:
- console.print("\n[yellow]Interrupted by user[/]")
- except Exception:
- console.print_exception(show_locals=False)
-
-```
-
-
-## File: docs/examples/markdown/content_source_example.py
-
-```py
-"""
-Example showing how to use the content_source parameter to control HTML input for markdown generation.
-"""
-import asyncio
-from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, DefaultMarkdownGenerator
-
-async def demo_content_source():
- """Demonstrates different content_source options for markdown generation."""
- url = "https://example.com" # Simple demo site
-
- print("Crawling with different content_source options...")
-
- # --- Example 1: Default Behavior (cleaned_html) ---
- # This uses the HTML after it has been processed by the scraping strategy
- # The HTML is cleaned, simplified, and optimized for readability
- default_generator = DefaultMarkdownGenerator() # content_source="cleaned_html" is default
- default_config = CrawlerRunConfig(markdown_generator=default_generator)
-
- # --- Example 2: Raw HTML ---
- # This uses the original HTML directly from the webpage
- # Preserves more original content but may include navigation, ads, etc.
- raw_generator = DefaultMarkdownGenerator(content_source="raw_html")
- raw_config = CrawlerRunConfig(markdown_generator=raw_generator)
-
- # --- Example 3: Fit HTML ---
- # This uses preprocessed HTML optimized for schema extraction
- # Better for structured data extraction but may lose some formatting
- fit_generator = DefaultMarkdownGenerator(content_source="fit_html")
- fit_config = CrawlerRunConfig(markdown_generator=fit_generator)
-
- # Execute all three crawlers in sequence
- async with AsyncWebCrawler() as crawler:
- # Default (cleaned_html)
- result_default = await crawler.arun(url=url, config=default_config)
-
- # Raw HTML
- result_raw = await crawler.arun(url=url, config=raw_config)
-
- # Fit HTML
- result_fit = await crawler.arun(url=url, config=fit_config)
-
- # Print a summary of the results
- print("\nMarkdown Generation Results:\n")
-
- print("1. Default (cleaned_html):")
- print(f" Length: {len(result_default.markdown.raw_markdown)} chars")
- print(f" First 80 chars: {result_default.markdown.raw_markdown[:80]}...\n")
-
- print("2. Raw HTML:")
- print(f" Length: {len(result_raw.markdown.raw_markdown)} chars")
- print(f" First 80 chars: {result_raw.markdown.raw_markdown[:80]}...\n")
-
- print("3. Fit HTML:")
- print(f" Length: {len(result_fit.markdown.raw_markdown)} chars")
- print(f" First 80 chars: {result_fit.markdown.raw_markdown[:80]}...\n")
-
- # Demonstrate differences in output
- print("\nKey Takeaways:")
- print("- cleaned_html: Best for readable, focused content")
- print("- raw_html: Preserves more original content, but may include noise")
- print("- fit_html: Optimized for schema extraction and structured data")
-
-if __name__ == "__main__":
- asyncio.run(demo_content_source())
-```
-
-
-## File: docs/examples/markdown/content_source_short_example.py
-
-```py
-"""
-Example demonstrating how to use the content_source parameter in MarkdownGenerationStrategy
-"""
-
-import asyncio
-from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, DefaultMarkdownGenerator
-
-async def demo_markdown_source_config():
- print("\n=== Demo: Configuring Markdown Source ===")
-
- # Example 1: Generate markdown from cleaned HTML (default behavior)
- cleaned_md_generator = DefaultMarkdownGenerator(content_source="cleaned_html")
- config_cleaned = CrawlerRunConfig(markdown_generator=cleaned_md_generator)
-
- async with AsyncWebCrawler() as crawler:
- result_cleaned = await crawler.arun(url="https://example.com", config=config_cleaned)
- print("Markdown from Cleaned HTML (default):")
- print(f" Length: {len(result_cleaned.markdown.raw_markdown)}")
- print(f" Start: {result_cleaned.markdown.raw_markdown[:100]}...")
-
- # Example 2: Generate markdown directly from raw HTML
- raw_md_generator = DefaultMarkdownGenerator(content_source="raw_html")
- config_raw = CrawlerRunConfig(markdown_generator=raw_md_generator)
-
- async with AsyncWebCrawler() as crawler:
- result_raw = await crawler.arun(url="https://example.com", config=config_raw)
- print("\nMarkdown from Raw HTML:")
- print(f" Length: {len(result_raw.markdown.raw_markdown)}")
- print(f" Start: {result_raw.markdown.raw_markdown[:100]}...")
-
- # Example 3: Generate markdown from preprocessed 'fit' HTML
- fit_md_generator = DefaultMarkdownGenerator(content_source="fit_html")
- config_fit = CrawlerRunConfig(markdown_generator=fit_md_generator)
-
- async with AsyncWebCrawler() as crawler:
- result_fit = await crawler.arun(url="https://example.com", config=config_fit)
- print("\nMarkdown from Fit HTML:")
- print(f" Length: {len(result_fit.markdown.raw_markdown)}")
- print(f" Start: {result_fit.markdown.raw_markdown[:100]}...")
-
-if __name__ == "__main__":
- asyncio.run(demo_markdown_source_config())
-```
-
-
-## File: docs/examples/tmp/console_test.html
-
-```html
-'
-
-
- \n
-
-
-
- \n
-
-
-
-
-
-
-
- Mobiles & Tablets - Mobiles
-
-
-
- 2400 items found in
- Smartphones
-
-
-
-
- Sort By:
-
-
-
-
- Best Match
-
-
-
- View:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM930.00
- Voucher
- save 15%
- Wp Kuala Lumpur
-
-
-
-
-
-
-
-
-
- RM899.00
-
- Selangor
-
-
-
-
-
-
-
-
-
- RM1,029.00
- Voucher
- save 21%
- Perak
-
-
-
-
-
-
-
-
-
- RM1,699.00
-
-
-
-
-
-
-
-
-
- RM2,249.00
- Voucher
- save 16%
- China
-
-
-
-
-
-
-
-
-
- RM269.00
- Voucher
- save 10%
- 139 sold
- (14)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM2,183.50
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM1,679.00
-
-
-
-
-
-
-
-
-
- RM1,243.00
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM689.00
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM4,999.00
- Voucher
- save 24%
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM759.00
-
-
-
-
-
-
-
-
-
-
- RM1,999.00
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- RM409.00
- Voucher
- save 55%
- 1.0K sold
-
-
-
-
-
-
-
-
-
-
- RM355.95
- Voucher
- save 41%
- 14.0K sold
-
-
-
-
-
-
-
-
-
-
-
-
- Category
-
-
-
-
-
-
-
-
-
-
- Service & Promotion
-
-
-
-
-
-
-
-
- Shipped From
-
-
-
-
- VIEW MORE
-
-
-
-
- Price
-
-
- -
-
-
-
-
- Rating
-
-
-
- -
-
-
-
-
-
-
-
- And Up
-
-
-
- Phone Features
-
-
-
-
-
-
-
- Operating System
-
-
-
-
-
-
-
- Condition
-
-
-
-
-
-
-
-
- Network Connections
-
-
-
-
-
-
-
-
- Number of Camera
-
-
-
-
-
-
-
-
- Screen Type
-
-
-
-
-
-
-
-
- RAM memory
-
-
-
-
-
-
-
-
- SIM card Slots
-
-
-
-
-
-
-
- Plug Type
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Innovation through the Mobile Phones in Malaysia
- Not too long ago, the smartphone was the most innovative piece of technology crafted by
- enthusiastic developers and forward-thinking creators. Its features are very
- outstanding, combining the capabilities of a computer, a cellphone, and a camera into
- one pocket device. The technology was very impressive, that those who dared to have one
- were only the rich, the famous and the influential. Even today, there is still no device
- that can compare to the advancement brought to us by this simple handhel...mobile
- phone reviews in Malaysia or read some mobile phone comparisons in
- Malaysia before you buy one for yourself. You can get a mobile for the best
- mobile price in Malaysia online today! Only on Lazada Malaysia.
- Mass production of mobile phones
- The turn of the tide for the mobile device began when the big companies started
- developing mobile phones that are affordable for the middle class. As these mobile
- groups continue to make business phones for the higher class, they would often release
- an affordable version that can appeal to a larger market. Eventually, the smaller tech
- companies got their share of the technology and began producing their own devices,
- comparable to those made by the likes of Lenovo, Asus, and Acer. The economics
- o...smartphone price in Malaysia on Lazada Malaysia.
-
-
-
-
-
-
- Flagship phone
- - Standard features: Also known as a high-end phone, this is basically the phone that
- carries the brand’s name. All of the best and finest specs and features, a
- smartphone can offer are put into the flagship device.
- - Technical specs: Flagships run the latest OS, upgradable to the next OS, and comes
- with fast processor speeds. In terms of memory, the flagship has large (albeit non
- expansive) storage, and at least 2GB RAM
- - Known flagship brands: Apple iPhone, Sony Xperia Z series, Samsung Galaxy S, LG
-
-
-
- Midrange phone
- - Standard features: As the name suggests, the devices that fall under this group are
- in the middle in terms of specs. The devices here are practical for most users,
- equipped with above-average features, with at least 3 flagship specs.
- - Technical Specs: Runs the latest OS with an OTA update for the next OS at optimum
- processor speeds. At least 1GB RAM, with expandable storage capacity via microSD
-
- - Known midrange brands: Sony Xperia E, Huawei Ascend, Asus Zenfone series, Lenovo
- phone series, Xiaomi
-
-
- Start up phones
- - Standard features: Known as the budget phone, these are the more affordable brands
- of phones, produced by companies specifically for those who are new to the
- smartphone.
- - Technical Specs: Runs either a previous OS or the latest OS. Decent processor
- speeds, topping at 1.5GHz under a dual-core chip. A much smaller internal storage,
- expandable via microSD, with a maximum of 1GB RAM
- - Known start-up brands: Cherry Mobile, MyPhone, Starmobile, ArcMobile, Kata
-
-
-
-
-
-
-
- \n \n\n \n \n \n\n\t
-
- \n \n \n\n \n \n \n \n \n \n
-
-
-'
-```
-
-
-## File: docs/examples/tmp/geo_test.png
-
-```png
-BM6� 6 (
- � � � �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ΰ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������SSSZZZ������|||������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK�����沲�YYY�����琐�vvv��KKKKKKsssPPP������KKK������KKK�����뿿�SSSWWW������^^^KKKMMM��������袢�MMM�����WWWKKKMMM��������͙��PPPKKKYYY�����묬�^^^���������MMM�����𝝝MMM������KKKKKK���KKK������PPPKKKXXX��������͟��MMM���������KKK���������������������������KKK���KKKKKKwww����������������뎎�PPPKKK\\\��������ﷷ�KKK���������KKK���������ZZZKKKKKK{{{���������WWWKKKMMM�����KKK��������ˌ�����������xxxKKKKKKaaa�����שּׁ�KKKKKKqqqPPP������KKK�����ӛ��MMM��ٌ��KKKKKKSSS�����짧�MMM������WWWKKKMMM���������|||KKKKKKiii�����橩�^^^������~~~������aaa������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK������\\\�����������PPP�����菏�KKK������KKK������KKK������~~~sss������gggrrr������MMM��������ċ����뿿�MMM���������KKK��߽��KKK�����߂��UUU��第�bbb���������MMM������SSS���������KKK������yyyKKK��뫫�KKK������xxxaaa������QQQ���������[[[������rrrRRR���fffSSS���������KKKbbb������MMM���������������KKK�����傂�WWW�����挌�KKK�����怀�KKK������vvv������SSS������MMM�����১�WWW������KKK���������}}}�����WWW������xxx������PPP�����ɞ��KKK������KKK������KKK������[[[�����XXX�����ʈ��������MMM�����嘘�KKK��ߑ��RRR������___www��aaa�����텅����������aaa������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK�����˯��\\\�����ˌ��~~~���SSS���������LLL������KKK������KKK������lll���������KKK��������Ӈ��������������������OOO��������뻻�������www���������KKK��Ū��bbb���������MMM������KKK���������KKK�����糳�KKK��디�nnn��������鸸�������KKK���������KKK��ŏ��kkk���]]]ZZZ���PPP������KKK��������zzz��ʀ����������ˍ��www���������KKK������^^^���vvv���RRR�����������������⠠�MMM������QQQ������������������KKK��������獍�yyy���bbb������������������UUU���������MMM������KKK���SSS��������������꼼�sssWWW���������������OOO������������ddd���������WWW��̫��bbb�����ͅ�����������aaa��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������뽽�KKK�����읝�]]]�����ꄄ�������VVVKKKMMMKKK������KKK������KKK������ggg���������KKK��������苋�jjj�����������裣�```���������������xxx������������KKK������aaa�����MMM������KKK��������돏�PPPKKKKKKKKK���zzz���������������������KKK���������\\\���fff�����椤�eee���{{{������KKK��������Σ��ccc���vvv���������ooo������������KKK������KKK���PPP���WWW���WWW������yyyKKKPPP�����夤�KKKKKKKKKKKKKKK������KKK��������興�������KKKKKKKKKKKKKKKZZZ��ꥥ�YYYKKKMMMKKK������KKKKKKMMM��������Ե��WWWKKKbbb��������������檪�___���������������PPP������������KKK��朜�aaa������}}}���������]]]������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK�����𮮮RRR�����숈�www���������������KKK������KKK������KKK������lll���������KKK��������zzz�����������˿��MMM��������賳���㊊�rrr�����缼�KKK��੩�QQQ�����QQQ������KKK�����������������彽�KKK��ɔ��nnn��������ݶ��������KKK�����纺�WWW���xxx������hhh��̆��������KKK���������|||�����恁�ttt�����kkk���������KKK��߯��ccc���dddwww������KKK��Х��QQQ���������������KKK���������KKK��־��KKK��������ˉ��������aaa���������{{{}}}���������������KKK������KKK���OOO���������MMM���������������������������MMM��������굵����ccc��������盛�ZZZ��שּׁ�UUU�����退�ttt������\\\���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������eee������������������������������������������������������������������������������������������������������������������������������������������KKKqqq���kkkKKK������WWW�����ҋ��hhh��ȕ��KKK������KKK������KKK������eee���������tttccc������KKK�����Θ��KKK������UUU~~~���}}}MMM������KKK������lll___��𮮮KKK������ggg}}}������KKK���������^^^���������WWW������KKK������dddmmm������KKK���������MMM����MMMnnnMMMiii���[[[������KKKXXX������KKK������KKK���������KKK������lllddd��҆�������쇇�KKK������bbb������RRR������MMM������TTT������rrr]]]������KKKlll�����ڀ�������뤤�OOO������MMM�����犊�iii������KKK������KKK��ܓ��UUU������TTT������~~~ttt���������������TTT~~~���{{{MMM��ߡ��MMM������TTT���������KKK������RRRMMM������KKK���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������fff[[[[[[�����������������������������������ᓓ����������������������������������������������������������������������������������������������SSS���LLL[[[���lllKKKggg�����sssMMMTTT���������SSS������KKK���uuuKKKMMMggg������wwwMMMXXX��������꼼���������ﹹ�kkkMMMaaa��������鱱�[[[MMMrrr�����ʰ��ppp{{{MMMsss������TTTKKKPPP���������```KKKYYY��������柟�___MMMnnn������WWWKKKOOO������zzz�����å�����������MMM������KKK���OOORRR��������Ύ�����]]]XXX��^^^MMMsss������ccc���������RRR����������ꅅ�MMMOOO��������볳�lllMMMkkk���������RRR���MMM������{{{�����핕�RRRWWW������������qqqMMMRRR���������KKK������eee������\\\KKKddd�����������������涶�jjjMMMaaa��������𐐐SSSRRR��������Ѳ��nnnyyyKKKlll���ZZZLLL���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������iii���������[[[[[[^^^������������������������������hhh[[[kkk������������������������������������������������������������������������������������������������������������������������������������������������������KKK������ggg���������������������������������������������������������������������������������������������������������KKK���������������������������������������������������KKK������������ZZZvvv��������ѓ��PPP���������KKK���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������hhh[[[���������[[[[[[[[[���������������������������ggg[[[[[[[[[jjj��������������������������������������������������������������������������������������������������������������������������������������貲�KKK������KKK�����孭���������������������������������������������������������������������������������������������������������ꛛ���������������������������������������������������ʗ����������������ꖖ�cccRRRbbb���������������KKK�����������������������������������������������������������������������������������������������������������������������������������Έ��������������������������������������������������KKK������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������nnn[[[\\\bbb[[[[[[[[[[[[������������������������eee[[[[[[[[[[[[[[[}}}��������������������������������������������������������������������������������������������������������������������������������������Ꚛ������䵵���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������浵������������������������������������������������˵�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���������������������fff[[[[[[[[[[[[[[[bbb���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������kkk[[[[[[[[[[[[[[[[[[]]]���������������ddd[[[[[[[[[[[[[[[eee��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ꔔ�iii[[[[[[[[[[[[[[[^^^���������ccc[[[[[[[[[[[[[[[hhh���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������\\\[[[[[[[[[^^^���������[[[[[[[[[[[[jjj������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������\\\[[[[[[[[[]]]���������[[[[[[kkk������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������\\\[[[[[[[[[]]]���������qqq��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ڷ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������]]][[[[[[[[[\\\������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������jjjKKKPPPKKK������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������^^^[[[[[[[[[\\\��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������諫����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������www�����갰�KKK���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������^^^[[[[[[[[[\\\���������������������������������������������������������������������������������������������������������KKKKKKKKKKKK^^^���������KKK������������cccKKKMMM������������bbbzzz������WWW��������KKKKKKRRR���������xxxKKKKKKaaa�����큁�������������KKKKKKKKKKKKKKK������xxxKKKKKKfff�����Ҁ��KKKKKKvvvKKK������KKK�����蜜�LLL��ڙ��KKKKKKSSS��������������������Ϊ��PPPlllzzzaaaZZZ���������������������KKKKKKKKKKKKKKK���������~~~KKKKKKwww�����������SSS������������[[[�����������������������ɂ��KKKKKKKKKKKKKKK���������UUUKKKQQQ���������xxxKKKKKKKKKKKKKKK�����琐�KKKKKKMMM������������������KKK���������������KKK��ԉ�������̋��������������������KKK��������礤�KKK��Ы��[[[��������͂��������KKK������KKK���������PPP���������WWWKKK�����������鬬�MMM��������Ԋ��TTT������zzzKKKKKK```���������OOOKKKMMM��������뛛�MMMKKKTTT������www��������������漼�KKK������������qqqKKKKKKeee���������ZZZKKKRRRxxxuuu������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������rrr[[[mmm������^^^[[[[[[[[[\\\������������������������������������������������������������������������������������������������������KKK�����ݬ�����KKK��徾�KKK���������gggsss��۱��MMM���������MMMRRR��빹�KKK[[[������[[[�����描�YYY��鐐�VVV������zzz�����灁�������������KKK��������������˓��XXX������zzz������KKK������yyyKKK������KKK������KKK������[[[�����挌�XXX��������������UUU�����������̱��PPP�����������������˄��KKK��Ƚ����������MMM������QQQ�����������λ��RRR������������^^^�����������������������KKK������������������VVV�����ᕕ�QQQ���������KKK��������ټ��������KKK������KKK���������������sss�����������ddd��ь��������������������������KKK���������___xxx��벲�^^^������MMMlll���WWWKKK������KKK���������PPP�����RRR������������������MMM���������KKK�����꒒�VVV������yyy������sss���������KKK��ի��KKK�����⊊�lll��遁�����������������TTT��������鑑�YYY������www������bbbqqq��ج��KKKuuu���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������nnn[[[[[[������������^^^[[[[[[[[[[[[vvvyyy������������������������������������������������������������������������������������������KKK������������KKK������KKK���������KKK���������}}}�����ﷷ�cccaaa��Ѥ��wwwMMM���������������rrrUUU���ccc������������������~~~������������KKK���������������]]]������������������KKK���������KKK������KKK���QQQ������������������tttUUU���������������TTT�����˟��fff�����ј��~~~������������������mmmlll������������hhh��������𝝝\\\���������RRR������������^^^��������������������������櫫�KKK���������������MMM���������PPP��������뻻�KKK��������������ϥ�����������```��������������袢�KKK���������KKK�����������猌�xxx���������������KKK�����ϲ��KKK�����β��^^^��닋�bbb�����驩�KKK������KKK���������OOO�����왙�ggg��������������徾�MMM�����円�ZZZ������ccc��������������������������և��KKK��ڍ��uuu��������������쁁����������������MMM���MMM������ccc������������������KKK���������vvvttt������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������iii[[[[[[������������������^^^[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������KKK��������蹹�KKK������KKK���������KKK��������ddd��ꊊ����������www���fff�����UUUKKKggg������KKKKKKKKKKKKKKK[[[���xxx������������KKK���������������KKKKKKKKKKKKKKKXXX��ꛛ�PPPKKKKKKKKK������KKKKKKMMM��������UUUKKKhhh��������������깹�```��츸�^^^���bbb������TTT���������������������\\\}}}���������RRR������������MMM��������湹�QQQ������������^^^�����촴�RRRRRRRRR___��������왙�MMM��������Ҭ��```���������jjj�����������𬬬LLL������������������������ZZZ������������������KKKPPPvvv]]]KKK�����匌�zzz������������������������KKK������VVV���������^^^���|||������������KKK������KKK���������PPP�����nnn������������������KKK������KKK���������KKKKKKKKKKKKKKKZZZ��鷷�eeeKKKYYY������```KKKKKKKKKKKKKKK��Ɓ�������������\�YYY���YYY������KKKKKKKKKKKKKKKZZZ���KKK��������镕�nnn������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������```[[[[[[[[[������������������������[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������KKKKKKUUUMMMSSS���������KKK���������KKK��������쀀�������[[[������fffMMM��ږ��ttt���MMM���������������aaa���������yyy{{{��怀�ttt���������KKK���������������eee��������烃�|||�����������槧�KKK������KKK���PPP���������MMM������������������������rrr������������������OOO������������������������PPP���������KKK������������KKK��������繹�SSS������������[[[�����������������������������텅�TTT�����ꆆ�ppp���������zzz��������������RRR���������KKK�����ː��KKK������������������|||��𗗗lll�����鉉������ԍ��������������������KKKfffppp[[[KKK�����粲�[[[��猌�www���������KKK������KKK���������KKK�����͚��nnn��������������멩�KKKpppoooOOORRR������bbb���������{{{{{{���ttteee�����������Ӕ��kkk�����IJ��PPP���vvv}}}���������zzz�����炂�|||���ggg��������܄��rrr���KKK���������vvvvvv���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������xxx[[[[[[[[[ooo������������������������[[[[[[[[[[[[[[[[[[[[[[[[sss���������������������������������������������������������������������������������KKK���������RRR�����KKKmmm������uuubbb������KKK������KKK������KKK[[[������RRR���TTT������uuurrr��𧧧OOO������MMM�����恁�KKK���������KKK��������������̢��PPP������MMM������[[[������UUU������KKK��ŕ��WWW������TTT������ssssss���������������ddd��Ҭ��ppp���ppp������RRR�����������������������KKK������OOO��������𫫫KKK��������˻��RRR������������^^^������������������������������������```�����𧧧^^^���������eee������������������ccc���������MMMhhhKKK[[[��������������������꿿�RRR���^^^��������Ӌ�������灁�������������������KKK��������擓�VVV��山�^^^��Ծ��KKK������jjjKKK������KKKlll��˂��KKK������}}}ccc������������������LLL���������eee�����𤤤OOO������MMM�����쁁�mmm������PPP��紴�KKK������YYY�����끁�KKK���������MMM���������KKK��栠�PPP������MMM������oooaaa������KKKvvv���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[���������������������������[[[[[[[[[[[[������```[[[bbb���������������������������������������������������������������������������������KKK��������튊�[[[������QQQ���MMM������yyyMMMZZZ�����鷷�iii������ttt���������TTT��ۯ��]]]KKKeee��������쒒�RRRWWW��������̋�����^^^YYY���KKK�����������������Γ��TTTVVV������������[[[KKK\\\���������KKK�����ʌ��mmm��ᰰ�\\\KKKddd������������������PPP�����̓��PPP~~~��Ϊ��uuu��������������ڃ�����������MMM������fff��������YYY����ã��SSS������zzz���^^^��������������������������������硡�\\\��MMM���������SSS�����갰���������𝝝```������KKK���������������������������������PPP���KKK���������}}}�����{{{���������������KKK��������齽�KKK��ж��nnn�����ѧ��WWWMMM���WWW������KKK���SSSSSS�����裣�MMMKKKRRR���������������MMM��������珏�___�����葑�SSSWWW������������mmmKKKUUU���������___MMM}}}������������ZZZ\\\���\\\���������^^^�����뒒�UUUUUU������������rrrMMMeeewwwttt������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������vvv[[[[[[[[[������������������������������___[[[[[[������������[[[������������������������������������������������������������������������������������KKK���������eeefff������������������������������������������������������������������������������������������������������������������������KKK���������������������������������������������������������KKK��������������������������������������������β��^^^�����������踸�QQQ������������������MMM���������KKK�����PPP������WWW�����ʲ��KKKnnnQQQ������dddZZZSSS�����������������������垞�]]]������lllwww������TTT�����К��PPP�����̠��\\\������nnnyyy������KKK��������������������������������Ԉ��KKKwww��������튊�xxx��숈�������������������KKK�����ಲ�mmm```������������������������������������KKK�����������������nnn������������������KKK�����Ĺ��TTT�����������������������������������������������������������������������������������������������������������������������������������ꖖ�ooo������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[ttt������������������������������������[[[[[[```���������uuu������������������������������������������������������������������������������������KKKKKKKKKKKKggg���������������������������������������������������������������������������������������������������������������������������KKK���������������������������������������������������������KKK�����������������������������������������������ԧ��RRRooozzzeeeZZZ��������������������MMMLLLKKK������������}}}KKKKKKuuu������������]]]TTT��������KKK���������������������������vvvKKKKKKYYY������������WWWKKKRRR������������tttKKKKKKVVV���������SSSKKKKKKKKKKKK��������������������貲�KKK�����������슊������ˍ��������������������KKKKKKKKKMMMggg�����뤤�QQQ���������������������������KKK��������������������Ʈ����������������믯�KKKKKKKKKOOO��������������������������������������������������������������������������������������������������������������������������������������뚚�ttt���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������jjj[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������곳���������������������������������������������������������ʸ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ٸ����������������������������ι����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������욚�dddddd�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ä�������������������������҈�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[\\\���������������[[[[[[[[[[[[���������������\\\[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������kkk[[[[[[[[[[[[���������������[[[[[[[[[[[[���������������[[[[[[[[[[[[mmm������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������kkk[[[[[[[[[[[[���������������[[[[[[[[[[[[���������������[[[[[[[[[[[[kkk���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[\\\���������������[[[[[[[[[[[[���������������\\\[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ш��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������wvv���������������������������������������������������������333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333������������������LLLccc���������������������������������������������������ZZZUTT������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ē�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������333���������������������������������������������������������333������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333333333333333������UTT333333333���������UTT333333xww~}}RQQ���������|{{333���������������HGG333333CCC������������������tss333333XXX���333���������������������gff333333333rqq������CCC333333kjj���������vuu333���������===UTT���������333������333���������vuu333���������CCCRQQ���������ccc333333333yyy������===UTT���������HGGLLL������333333===���������������CCC_^^���������|{{333���������������333333333RQQ������������RQQOOO���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������{{{}}}}}}}}}}}}}}}���������������������������������ccc333������������������333CCC���������������333~}}���_^^333OOO���������333333===���������333XXX������������������������333_^^���zyy333333������������������333===zyy������rqq������333LLL������333ZZZ������vuu333���������===UTT���������333������333���������vuu333���������===RQQ������HGG333���������}||������===UTT���������HGGLLL������OOO333���������������������333���������������333ihh������������kjj���������HGG333���������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������~~~���������������������������ccc333���������������333������������������xww333���������333OOO������333vuu333���������RQQ333���������������������������333���������HGG333������������������333333������������������xww333���������tss333������vuu333���������===UTT���������333������333���������vuu333���������===RQQ���333���������������������===UTT���������HGGLLL������333_^^������������������333���������������ihh333���������������������������333xww������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333���������������ZZZ333������������������333HGG������===OOO������ccc333���333ihh������333===������������������������������333333����_^^333������������������333yyy������������������XXX333���������333������vuu333���������===UTT���������333������333���������vuu333���������===RQQ���333rqq������������������===RQQ���������HGGLLL������333gff������������������333���������������333�������������������������333ZZZ���������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333���������������ccc333ZZZ_^^_^^333333������~}}bbbUTT333OOO������333rqq���rqq333������333333_^^_^^ZZZ333nnn�����������������Њ��ihhXXX===333���������������333���������������������`__333���������333������vuu333���������======���������333������333���������rqq333���������===RQQ���333LLL_^^_^^CCC333������===333���������CCCLLL������333gff������������������333������������������XXX333���������������������yyy333������������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333���������������333���������CCCbbb������������������333bbb���333������333������XXX333���������333������������������������������`__333���������������333���������������������333���������fff333������vuu333���������333333������333������333yyy������XXX333���������333\[[���333���������rqq333������===333���������333UTT������333gff������������������333������������������333���������333333333333LLL���������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333������������������===CCC���kjj333���������}||rqq���lkk333������LLL333���������333OOO���333ZZZ���RQQ333������������������_^^������333vuu���������������333������������������������===333rqqfff333xww������vuu333===���_^^333333===yyyCCC333������333333tssvuu333333333rqqRQQ333���������XXX333������333vuu������===333333xwwRQQ333���鋊�333HGG���������������������333���������������������HGGCCC������333���������������������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333���������������������nmm===ZZZ������������XXX===LLL���������OOO������������OOO������`__===gff���������������������ccc======}||���������������������333===������������������������rqq===UTT������������ppp���CCC===rqq��߅��CCCUTT���������OOO���UTT333_^^��ͦ��OOOHGG���������������{{{HGGLLL������������_^^������===LLL���������333333OOO`__���������������CCC_^^������������������333������333���������������������RQQOOO���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333���������������������������������������������������������������������������������������������������������������������������������������������������������������333OOO������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ihhgff���������������������333�����ꬫ�������������333UTT���333���������������������333������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ccc333������������������������������������������������������������������������������������������������������������������������������������������������������������������===333333333CCC��������������������������������������������������������������������������������������������������������������������������������������������������������������������̼��������������������������OOOUTT���333333333333333333333������333333333333333������UTTZZZ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������~}}������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������㟞�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[���[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[������������������[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[������������������[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[������������������[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[������������������[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ddd[[[[[[[[[������������������[[[[[[[[[eee������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[������������������[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ـ��```[[[[[[```������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Ƶ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������v��<��!��!��<��w���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������CCC333333333333nnn������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������r������������������t���������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���~}}333��������樦�333������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������P����������������������P���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������333������������333nnn���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������q����������������������������t������������������������������ccc333�����������������튉�333333CCC���333������vuu333���������������333333rqq���===UTT���������HGGLLL���������ccc333333333yyy������===RQQ������������������������333������������LLL333������UTT333333333���������===333333���RQQ���������===333===���333������333������vuu333���������~}}333������xww333333333333333������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������'��������'����������������������������������������ccc333������������������333HGG������333333������vuu333���������������333HGG���������===UTT���������HGGLLL������HGG333���������}||������===RQQ������������������������333���������333���������333CCC���������������ZZZ333������HGG333���������333333������333333������333������vuu333���������}||333������tss333������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������u��������������@��B��������������w���������������������������ccc333���������������333���������nmm333������vuu333���������������333������������===UTT���������HGGLLL���333���������������������===RQQ������������������������333���������333LLL������333������������������===333������333������333���������333������333������vuu333���������}||333������===������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������:�������������۲�۲��8������������<���������������������������ccc333���������������333���������333������vuu333���������������333������������===UTT���������HGGLLL���333rqq������������������===RQQ������������������������333������rqq333���������ZZZ333������������������333\[[������333������333���������333������333������vuu333���������}||333������333333333HGG���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������"��������������������m������������#���������������������������ccc333XXXXXXXXX}||���333���������333������vuu333���������������333������������======���������CCCLLL���333LLL_^^_^^CCC333������======������������������������333333===333LLL���������ccc333ZZZ_^^_^^333333�����꺹����\[[OOO333������333���������333������333������vuu333���������{{{333������===CCC������333_^^������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������!�������������֩��������.����������"���������������������������ccc333gffihhihh������333���������333������vuu333���������������333������������===333���������333ZZZ���333���������rqq333������===333������������������������333XXX}||OOO333UTT������333���������CCCbbb������������������333������333���������vuu333������333������vuu333���������OOO333������333gff������LLL===������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������:����������6��6��&�������������������<���������������������������ccc333���������������333���������333������vuu333333OOOlkk���vuu333`__���������===333CCC���RQQ333���������XXX333������333vuu������======333`__������������������333���������{{{333���������===CCC���kjj333���������UTT������UTT333���������333333cccUTT333333������333������vuu333333gffgff333LLL������UTT333������333LLL������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������t����������������F��R��������(��������v���������������������������ccc333���������������OOO���������OOO������rqq���RQQ333���ccc333===OOO������===UTT���CCCCCCxww������������{{{HGGLLL������������_^^������CCCZZZ���������������333���������333������������nmm===ZZZ�����������ㆅ�OOO333ZZZ���������������\[[333ZZZ���333������OOO������ppp���LLL===~}}������������lkk===333LLLOOOihh���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ש�����������������������������������������������������ccc333���������������������������������������������������������������333������������===UTT���������������������������������������������������������������������������333rqq������===333���������������������������������������������������������������������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������o��������$�ѝ�������ݷ��@��������r������������������������������ccc333333333333333���������������������������������������������������������������===UTT���������������������������������������������������������������������������333333333333CCC������������������������������������������������������������������������333������333���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������N����������������������O���������������������������������������������������������������������������������������������������������������������ihhxww������������������������������������������������������������������������������������������������������������������������������������������������������������������\[[��������Ћ�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������p������������������q���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������t��;�� �� ��;��u���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������[[[[[[[[[[[[[[[[[[[[[[[[��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������*** (((���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������III MMM������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������� ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������??? CCC������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" &&&������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������KKK RRRRRR OOO������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ NNN������������MMM ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ ������������������
-
-
- ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ <<<������������������<<<