diff --git a/README.md b/README.md index cb8a3032..f5ae19ce 100644 --- a/README.md +++ b/README.md @@ -176,14 +176,14 @@ As of now, LLM inference is supported for TGI, vLLM, OpenAI, Azure, Azure OpenAI SyGra can be used as a reusable platform to build different categories of tasks on top of the same graph execution engine, node types, processors, and metric infrastructure. -### Eval +### Evaluation Evaluation tasks live under `tasks/eval` and provide a standard pattern for: - Computing **unit metrics** per record during graph execution - Computing **aggregator metrics** after the run via graph post-processing -See: [`tasks/eval/README.md`](https://github.com/ServiceNow/SyGra/blob/main/tasks/eval/README.md) +See: [Read the full Evaluation documentation →](https://servicenow.github.io/evaluation/) diff --git a/docs/eval/README.md b/docs/eval/README.md new file mode 100644 index 00000000..0bdfef2c --- /dev/null +++ b/docs/eval/README.md @@ -0,0 +1,919 @@ +# Evaluation Tasks + +SyGra is a graph-oriented workflow framework for synthetic data generation **and evaluation**. This guide explains how to build, configure, and run evaluation tasks. + +--- + +## Table of Contents + +1. [Quick Start](#quick-start) +2. [Core Concepts](#core-concepts) +3. [Evaluation Workflow](#evaluation-workflow) +4. [Configuration Guide](#configuration-guide) +5. [Output Files](#output-files) +6. [Complete Examples](#complete-examples) +7. [Extending Evaluation](#extending-evaluation) +8. [Troubleshooting](#troubleshooting) + +[//]: # (9. [Best Practices](#best-practices)) + +--- + +## Quick Start + +### Running an Evaluation Task + +```bash +# Basic usage +uv run python main.py --task tasks.eval.question_answering.simpleqa --num_records 50 + +# Alternative path format +uv run python main.py --task eval/classification/simpleqa --num_records 50 + +# Specify output directory +uv run python main.py \ + --task tasks.eval.question_answering.simpleqa \ + --num_records 50 \ + --output_dir /abs/path/to/my_eval_outputs +``` + +### What You Get + +Every evaluation run produces two main outputs: + +1. **`output_*.json`** - Per-record results with unit metric evaluations +2. **`MetricCollatorPostProcessor_*.json`** - Aggregated metrics report + +--- + +## Core Concepts + +### Two-Layer Metric Architecture + +SyGra evaluation uses a two-layer architecture: + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Layer 1: Unit Metrics (Per-Record Validation) │ +│ ───────────────────────────────────────────────────────── │ +│ • Computed INSIDE the graph during execution │ +│ • Validate individual predictions (e.g., exact_match) │ +│ • Stored in state: exact_match, fuzzy_match, etc. │ +│ • Output: UnitMetricResult objects │ +└─────────────────────────────────────────────────────────────┘ + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Layer 2: Aggregator Metrics (Dataset-Level Statistics) │ +│ ───────────────────────────────────────────────────────── │ +│ • Computed AFTER the run via post-processing │ +│ • Aggregate unit results (e.g., accuracy, precision) │ +│ • Consume UnitMetricResult lists │ +│ • Output: Statistical summaries │ +└─────────────────────────────────────────────────────────────┘ +``` + +### Key Components + +| Component | Location | Purpose | +|-----------|----------|---------| +| **UnitMetrics** | `tasks/eval/utils.py` | Generic lambda node for computing unit metrics | +| **MetricCollatorPostProcessor** | `tasks/eval/utils.py` | Generic post-processor for aggregating metrics | +| **UnitMetricRegistry** | `sygra.core.eval.metrics.unit_metrics.unit_metric_registry` | Auto-discovers and instantiates unit metrics | +| **AggregatorMetricRegistry** | `sygra.core.eval.metrics.aggregator_metrics.aggregator_metric_registry` | Auto-discovers and instantiates aggregator metrics | + +--- + +## Evaluation Workflow + +### Step-by-Step Execution + +``` +1. Load Configuration + ├─ Read graph_config.yaml + └─ Load dataset from data_config.source + +2. Execute Graph (Per Record) + ├─ Run LLM/lambda/sampler nodes + ├─ Generate predictions + └─ Compute unit metrics (inside graph) + └─ Store results in state (e.g., exact_match, fuzzy_match) + +3. Write Per-Record Output + └─ Save output_*.json with all state fields + +4. Run Post-Processors + ├─ Load output_*.json + ├─ Apply each graph_post_process processor + └─ MetricCollatorPostProcessor aggregates metrics + +5. Write Aggregated Report + └─ Save MetricCollatorPostProcessor_*.json +``` + +### Data Flow + +``` +Input Dataset + ↓ +┌───────────────────────────────────────┐ +│ Graph Execution (Per Record) │ +│ ├─ LLM generates prediction │ +│ └─ UnitMetrics evaluates │ +│ ├─ exact_match: True/False │ +│ └─ fuzzy_match: True/False │ +└───────────────────────────────────────┘ + ↓ +output_*.json + ├─ Record 1: {prediction, exact_match, fuzzy_match} + ├─ Record 2: {prediction, exact_match, fuzzy_match} + └─ Record N: {prediction, exact_match, fuzzy_match} + ↓ +┌───────────────────────────────────────┐ +│ MetricCollatorPostProcessor │ +│ ├─ exact_match-accuracy: 0.85 │ +│ ├─ exact_match-precision: 0.90 │ +│ ├─ fuzzy_match-accuracy: 0.92 │ +│ └─ fuzzy_match-precision: 0.94 │ +└───────────────────────────────────────┘ + ↓ +MetricCollatorPostProcessor_*.json +``` + +--- + +## Configuration Guide + +### Unit Metrics Configuration + +Unit metrics are configured in the graph as a lambda node. + +#### Basic Example: Single Unit Metric + +```yaml +unit_metrics: + node_type: lambda + lambda: tasks.eval.utils.UnitMetrics + golden_key: "answer" + predicted_key: "predicted_answer" + unit_metrics_map: + - name: "exact_match" + params: + key: "text" + output_keys: + - exact_match +``` + +**What this does:** +- Compares `answer.text` (golden) with `predicted_answer.text` (predicted) +- Stores result in state as `exact_match` +- Includes `exact_match` in output file + +#### Advanced Example: Multiple Unit Metrics + +```yaml +unit_metrics: + node_type: lambda + lambda: tasks.eval.utils.UnitMetrics + golden_key: "answer" + predicted_key: "predicted_answer" + unit_metrics_map: + - name: "exact_match" + params: + key: "text" + - name: "fuzzy_match" + params: + key: "text" + threshold: 0.8 + output_keys: + - exact_match + - fuzzy_match +``` + +**What this does:** +- Evaluates both exact and fuzzy matching +- `exact_match`: Requires perfect string match +- `fuzzy_match`: Requires ≥80% similarity +- Both results stored in state and output + +#### Available Unit Metrics + +| Metric | Purpose | Key Parameters | +|--------|---------|----------------| +| `exact_match` | Exact string matching | `key`, `case_sensitive`, `normalize_whitespace` | +| `fuzzy_match` | Similarity-based matching | `key`, `threshold` (0.0-1.0), `case_sensitive` | +| `action_within_bbox` | Coordinate validation | `tolerance` | +| `typed_value_match` | Text input validation | `case_sensitive`, `normalize_whitespace` | +| `scroll_direction` | Direction validation | - | + +### Aggregator Metrics Configuration + +Aggregator metrics are configured in `graph_post_process`. + +#### Basic Example: Single Unit Metric Source + +```yaml +graph_post_process: + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "exact_match" +``` + +**What this does:** +- Computes accuracy from `exact_match` results +- Output key: `exact_match-accuracy` + +#### Advanced Example: Multiple Unit Metric Sources + +```yaml +graph_post_process: + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + # Metrics for exact match + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "exact_match" + - name: "precision" + params: + predicted_key: "text" + unit_metrics_results: + - "exact_match" + + # Metrics for fuzzy match + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "fuzzy_match" + - name: "precision" + params: + predicted_key: "text" + unit_metrics_results: + - "fuzzy_match" +``` + +**What this does:** +- Computes accuracy and precision for both exact and fuzzy matching +- Output keys: `exact_match-accuracy`, `exact_match-precision`, `fuzzy_match-accuracy`, `fuzzy_match-precision` +- Allows comparison of different validation criteria + +#### Available Aggregator Metrics + +| Metric | Purpose | Required Parameters | +|--------|---------|---------------------| +| `accuracy` | Overall correctness | `key` | +| `precision` | Quality of positive predictions | `predicted_key` | +| `recall` | Coverage of actual positives | `golden_key` | +| `f1_score` | Balanced precision-recall | `predicted_key`, `golden_key` | + +### Output Mapping + +Always include unit metric fields in `output_config`: + +```yaml +output_config: + output_map: + id: + from: "id" + answer: + from: "answer" + predicted_answer: + from: "predicted_answer" + exact_match: + from: "exact_match" + fuzzy_match: + from: "fuzzy_match" +``` + +--- + +## Output Files + +### 1. Per-Record Output: `output_*.json` + +Contains individual record results with unit metric evaluations. + +**Structure:** +```json +[ + { + "id": "q001", + "answer": {"text": "Paris"}, + "predicted_answer": {"text": "paris"}, + "exact_match": { + "correct": true, + "golden": {"text": "Paris"}, + "predicted": {"text": "paris"}, + "metadata": { + "validator": "exact_match", + "case_sensitive": false + } + }, + "fuzzy_match": { + "correct": true, + "golden": {"text": "Paris"}, + "predicted": {"text": "paris"}, + "metadata": { + "validator": "fuzzy_match", + "similarity": 1.0, + "threshold": 0.8 + } + } + } +] +``` + +**Key Points:** +- One entry per evaluated record +- Contains original data + predictions + unit metric results +- Unit metric results are `UnitMetricResult` objects (serialized as dicts) + +### 2. Aggregated Report: `MetricCollatorPostProcessor_*.json` + +Contains dataset-level statistics aggregated from unit metrics. + +**Structure:** +```json +[ + { + "evaluation_summary": { + "total_records": 1000, + "timestamp": "2026-02-20 00:17:57", + "status": "success" + }, + "results": { + "exact_match-accuracy": { + "accuracy": 0.737 + }, + "exact_match-precision": { + "average_precision": 0.828, + "precision_per_class": { + "Music": 0.968, + "Politics": 0.967, + "Other": 0.672 + } + }, + "fuzzy_match-accuracy": { + "accuracy": 0.856 + }, + "fuzzy_match-precision": { + "average_precision": 0.901, + "precision_per_class": { + "Music": 0.985, + "Politics": 0.978, + "Other": 0.740 + } + } + } + } +] +``` + +**Key Points:** +- Single report object (in a list) +- `evaluation_summary`: Metadata about the run +- `results`: Keyed as `{unit_metric}-{aggregator_metric}` +- Classification metrics include per-class breakdowns + +**Status Values:** +- `success`: All records processed +- `no_data`: No records to evaluate +- `fatal_error`: Critical error (includes error message) + +**Result Key Format:** +``` +{unit_metrics_field}-{aggregator_metric_name} + +Examples: +- exact_match-accuracy +- exact_match-precision +- fuzzy_match-accuracy +- fuzzy_match-f1_score +``` + +--- + +## Complete Examples + +### Example 1: Question Answering with Multiple Validators + +**File:** `tasks/eval/question_answering/simpleqa/graph_config.yaml` + +```yaml +# Unit metrics node +unit_metrics: + node_type: lambda + lambda: tasks.eval.utils.UnitMetrics + golden_key: "answer" + predicted_key: "predicted_answer" + unit_metrics_map: + - name: "exact_match" + params: + key: "text" + - name: "fuzzy_match" + params: + key: "text" + threshold: 0.8 + output_keys: + - exact_match + - fuzzy_match + +# Output configuration +output_config: + output_map: + id: + from: "id" + answer: + from: "answer" + predicted_answer: + from: "predicted_answer" + exact_match: + from: "exact_match" + fuzzy_match: + from: "fuzzy_match" + +# Aggregator metrics +graph_post_process: + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "exact_match" + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "fuzzy_match" +``` + +**Output:** +- `output_*.json`: Contains `exact_match` and `fuzzy_match` for each question +- `MetricCollatorPostProcessor_*.json`: Contains `exact_match-accuracy` and `fuzzy_match-accuracy` + +### Example 2: Classification with Multiple Metrics + +**File:** `tasks/eval/classification/simpleqa/graph_config.yaml` + +```yaml +# Unit metrics node +unit_metrics: + node_type: lambda + lambda: tasks.eval.utils.UnitMetrics + golden_key: "topic" + predicted_key: "predicted_topic" + unit_metrics_map: + - name: "exact_match" + params: + key: "text" + output_keys: + - exact_match + +# Aggregator metrics +graph_post_process: + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "exact_match" + - name: "precision" + params: + predicted_key: "text" + unit_metrics_results: + - "exact_match" + - name: "recall" + params: + golden_key: "text" + unit_metrics_results: + - "exact_match" + - name: "f1_score" + params: + predicted_key: "text" + golden_key: "text" + unit_metrics_results: + - "exact_match" +``` + +**Output:** +- `MetricCollatorPostProcessor_*.json`: Contains accuracy, precision, recall, and F1 score with per-class breakdowns + +--- + +## Extending Evaluation + +### Adding a New Unit Metric + +**Steps:** + +1. **Create metric class** in `sygra/core/eval/metrics/unit_metrics/` + +```python +from sygra.core.eval.metrics.unit_metrics.base_unit_metric import BaseUnitMetric +from sygra.core.eval.metrics.unit_metrics.unit_metric_registry import unit_metric +from sygra.core.eval.metrics.unit_metrics.unit_metric_result import UnitMetricResult + +@unit_metric("my_custom_metric") +class MyCustomMetric(BaseUnitMetric): + def __init__(self, **config): + super().__init__(**config) + self.validate_config() + self.metadata = self.get_metadata() + + def validate_config(self): + # Validate configuration + pass + + def get_metadata(self): + # Return metric metadata + pass + + def evaluate(self, golden, predicted): + # Implement evaluation logic + results = [] + for g, p in zip(golden, predicted): + is_correct = # your logic + results.append(UnitMetricResult( + correct=is_correct, + golden=g, + predicted=p, + metadata={"validator": "my_custom_metric"} + )) + return results +``` + +2. **Use in graph config** + +```yaml +unit_metrics_map: + - name: "my_custom_metric" + params: + # your parameters +``` + +**Auto-Discovery:** The `UnitMetricRegistry` automatically discovers and registers all metrics in the `unit_metrics` directory. + +### Custom Lambda Node for Unit Metrics + +For more complex evaluation logic or when you need full control over the unit metric calculation process, you can create a **custom lambda node** instead of using the generic `tasks.eval.utils.UnitMetrics`. + +**When to use a custom lambda node:** + +- Complex validation logic that doesn't fit standard unit metrics +- Need to access multiple state fields or external resources +- Custom data transformations before evaluation +- Domain-specific evaluation requirements + +**Example: Custom Unit Metrics Lambda** + +```python +# tasks/eval/my_task/custom_evaluator.py + +from typing import Any, Dict +from sygra.core.state import SygraState + +class CustomUnitMetricsLambda: + """Custom lambda for specialized unit metric calculation.""" + + def __init__(self, golden_key: str, predicted_key: str, **config): + self.golden_key = golden_key + self.predicted_key = predicted_key + self.config = config + + def __call__(self, state: SygraState) -> Dict[str, Any]: + """ + Compute custom unit metrics. + + Returns: + Dict with metric results to be stored in state + """ + golden = state.get(self.golden_key) + predicted = state.get(self.predicted_key) + + # Custom evaluation logic + custom_result = self._evaluate_custom(golden, predicted) + + # Store results in state + state["custom_metric"] = custom_result + + return {"custom_metric": custom_result} + + def _evaluate_custom(self, golden, predicted): + """Implement your custom evaluation logic.""" + # Example: Complex multi-field validation + return { + "correct": self._check_correctness(golden, predicted), + "golden": golden, + "predicted": predicted, + "metadata": { + "validator": "custom_metric", + "confidence": self._calculate_confidence(predicted) + } + } +``` + +**Use in graph config:** + +```yaml +unit_metrics: + node_type: lambda + lambda: tasks.eval.my_task.custom_evaluator.CustomUnitMetricsLambda + golden_key: "answer" + predicted_key: "predicted_answer" + output_keys: + - custom_metric + +output_config: + output_map: + custom_metric: + from: "custom_metric" +``` + +**Benefits:** + +- Full control over evaluation logic +- Access to entire state and graph context +- Can perform multi-step validation +- Easier debugging for complex scenarios + +### Adding a New Aggregator Metric + +**Steps:** + +1. **Create metric class** in `sygra/core/eval/metrics/aggregator_metrics/` + +```python +from sygra.core.eval.metrics.aggregator_metrics.base_aggregator_metric import BaseAggregatorMetric +from sygra.core.eval.metrics.aggregator_metrics.aggregator_metric_registry import aggregator_metric + +@aggregator_metric("my_aggregator") +class MyAggregatorMetric(BaseAggregatorMetric): + def calculate(self, unit_metric_results): + # Aggregate unit metric results + # Return dict with metric values + return {"my_metric": value} +``` + +2. **Use in graph config** + +```yaml +aggregator_metrics_map: + - name: "my_aggregator" + params: + # your parameters + unit_metrics_results: + - "exact_match" +``` + +### Custom Post-Processor for Aggregator Metrics + +For advanced aggregation requirements or custom report formats, you can create a **custom graph post-processor** instead of using the generic `tasks.eval.utils.MetricCollatorPostProcessor`. + +**When to use a custom post-processor:** + +- Need custom report format or structure +- Complex aggregation logic beyond standard metrics +- Multiple data sources or external integrations +- Custom statistical analysis or visualizations +- Domain-specific reporting requirements + +**Example: Custom Aggregator Post-Processor** + +```python +# tasks/eval/my_task/custom_aggregator.py + +import json +from typing import Any, Dict, List +from sygra.core.graph.graph_postprocessor import GraphPostProcessor + +class CustomMetricAggregator(GraphPostProcessor): + """Custom post-processor for specialized metric aggregation.""" + + def __init__(self, **config): + """ + Initialize custom aggregator. + + Args: + config: Custom configuration parameters + """ + super().__init__() + self.config = config + self.custom_threshold = config.get("threshold", 0.8) + + def process(self, output_data: List[Dict[str, Any]]) -> Dict[str, Any]: + """ + Process output data and compute custom aggregated metrics. + + Args: + output_data: List of records from output_*.json + + Returns: + Dict with aggregated results + """ + # Extract unit metric results + unit_results = [ + record.get("custom_metric") + for record in output_data + if "custom_metric" in record + ] + + # Custom aggregation logic + total = len(unit_results) + correct = sum(1 for r in unit_results if r.get("correct", False)) + + # Calculate custom metrics + accuracy = correct / total if total > 0 else 0.0 + high_confidence = sum( + 1 for r in unit_results + if r.get("metadata", {}).get("confidence", 0) >= self.custom_threshold + ) + + # Build custom report structure + report = { + "evaluation_summary": { + "total_records": total, + "correct_predictions": correct, + "status": "success" if total > 0 else "no_data" + }, + "metrics": { + "accuracy": accuracy, + "high_confidence_rate": high_confidence / total if total > 0 else 0.0 + }, + "custom_analysis": self._perform_custom_analysis(unit_results) + } + + return report + + def _perform_custom_analysis(self, results: List[Dict]) -> Dict: + """Perform domain-specific analysis.""" + # Example: Custom statistical analysis + return { + "distribution": self._calculate_distribution(results), + "confidence_stats": self._calculate_confidence_stats(results) + } +``` + +**Use in graph config:** + +```yaml +graph_post_process: + - processor: tasks.eval.my_task.custom_aggregator.CustomMetricAggregator + params: + threshold: 0.85 + # any custom parameters +``` + +**Output file:** `CustomMetricAggregator_*.json` + +**Benefits:** + +- Complete control over aggregation logic +- Custom report structure and format +- Can integrate external data sources +- Flexible statistical analysis +- Domain-specific metrics and visualizations + +**Example: Combining Standard and Custom Post-Processors** + +You can use both standard and custom post-processors together: + +```yaml +graph_post_process: + # Standard metrics for common analysis + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "exact_match" + + # Custom metrics for specialized analysis + - processor: tasks.eval.my_task.custom_aggregator.CustomMetricAggregator + params: + threshold: 0.85 +``` + +This produces two output files: + +- `MetricCollatorPostProcessor_*.json` - Standard metrics +- `CustomMetricAggregator_*.json` - Custom analysis + +--- + +## Troubleshooting + +### Common Issues + +#### Missing Unit Metric Fields + +**Error:** +``` +KeyError: 'exact_match' not found in output columns +``` + +**Solution:** +Ensure unit metric fields are in `output_config.output_map`: + +```yaml +output_config: + output_map: + exact_match: + from: "exact_match" +``` + +#### Mismatched Unit Metrics Configuration + +**Error:** +``` +unit_metrics_results field 'fuzzy_match' not found +``` + +**Solution:** +Ensure `unit_metrics_results` matches `output_keys`: + +```yaml +# Unit metrics node +output_keys: + - exact_match + - fuzzy_match + +# Aggregator config +unit_metrics_results: + - "exact_match" # ✓ Matches output_keys + - "fuzzy_match" # ✓ Matches output_keys +``` + +#### Memory Issues with Large Datasets + +**Issue:** Post-processing loads entire output file into memory + +**Solutions:** + +- Process in batches +- Use JSONL format with custom streaming post-processor +- Filter records before post-processing + +[//]: # (### Best Practices) + +[//]: # () +[//]: # (**Always validate configuration**) + +[//]: # () +[//]: # (- Run with small `--num_records` first) + +[//]: # (- Check output files before full run) + +[//]: # () +[//]: # (**Use descriptive names**) + +[//]: # () +[//]: # (- Name unit metrics clearly (e.g., `exact_match`, `fuzzy_match_80`)) + +[//]: # (- Use consistent naming conventions) + +[//]: # () +[//]: # (**Document thresholds**) + +[//]: # () +[//]: # (- Comment threshold values in config) + +[//]: # (- Track threshold changes in version control) + +[//]: # () +[//]: # (**Monitor output sizes**) + +[//]: # () +[//]: # (- Large unit metric metadata can bloat output files) + +[//]: # (- Consider removing verbose metadata for production runs) + +[//]: # (---) + +[//]: # () +[//]: # (## Additional Resources) + +[//]: # () +[//]: # (- **Unit Metrics Reference:** `docs/eval/metrics/unit_metrics_summary.md`) + +[//]: # (- **Aggregator Metrics Reference:** `docs/eval/metrics/aggregator_metrics_summary.md`) + +[//]: # (- **Metrics Overview:** `docs/eval/metrics/README.md`) + +[//]: # () +[//]: # (---) + +[//]: # () +[//]: # (**Last Updated:** February 2026) diff --git a/docs/eval/agents/web_agents_eval.md b/docs/eval/agents/web_agents_eval.md new file mode 100644 index 00000000..2f7cafcd --- /dev/null +++ b/docs/eval/agents/web_agents_eval.md @@ -0,0 +1,623 @@ +# Web Agents Evaluation + +## Overview + +The `eval.agents.web_agents` module provides a comprehensive framework for evaluating browser automation agents. It includes tools for web interaction, request/response logging, retry logic with intelligent failure hints, inline evaluation, and metrics calculation. + +## Architecture + +### Core Components + +1. **Task Executor** (`task_executor.py`) - Main execution logic with pre/post processors +2. **Tools** (`tools.py`) - Browser interaction tools (click, type, scroll, etc.) +3. **Constants** (`constants.py`) - Configuration constants and state keys +4. **Graph Config** (`graph_config.yaml`) - Workflow configuration and system prompts + +## Module Structure + +``` +tasks/eval/agents/web_agents/ +├── task_executor.py # Core execution logic +├── tools.py # Browser interaction tools +├── constants.py # Configuration constants +├── graph_config.yaml # Workflow and evaluation config +├── chat_history_seed.json # Sample input data +├── logs/ # Request/response logs +├── metadata/ # Execution metadata +└── README.md # This file +``` + +--- + +## Components + +### 1. Task Executor (`task_executor.py`) + +The task executor provides several classes for managing the evaluation workflow: + +#### `RequestResponseLogger` + +Comprehensive logging system for tracking exact request/response payloads. + +**Methods:** +- `setup_logger()` - Initialize logging directory and file structure +- `log_request(request_payload, step_number)` - Log requests sent to the model +- `log_response(response_payload, step_number)` - Log responses received from the model +- `is_server_error(response)` - Detect server errors in responses + +**Log Format:** +```json +{ + "step": 1, + "timestamp": "2026-03-05T12:00:00", + "type": "request|response", + "payload": {...} +} +``` + +#### `FetchNextActionPreProcessor` + +Pre-processes requests before sending to the model. + +**Key Features:** +- Manages chat history and state +- Handles retry logic with failure hints +- Injects retry prompts when needed +- Manages screenshot scaling + +**Methods:** +- `retry_failure_and_chat_injection(cls, state, lambda_node_dict)` - Inject retry hints into chat +- `apply(cls, lambda_node_dict, state)` - Main preprocessing logic + +**Retry Hints:** +- **Tool Incorrect**: Guides agent to use different tool +- **Parameters Incorrect**: Guides agent to fix parameters for same tool + +#### `FetchNextActionPostProcessor` + +Post-processes model responses. + +**Key Features:** +- Logs responses +- Extracts tool calls from model output +- Handles server errors +- Updates state with model responses + +**Methods:** +- `apply(cls, lambda_node_dict, state, messages)` - Main post-processing logic + +#### `InlineEvaluationLambda` + +Performs inline evaluation of model predictions against golden responses. + +**Evaluation Metrics:** +- **Tool Match**: Exact match of predicted vs golden tool +- **Step Match**: Comprehensive validation including: + - Tool correctness + - Parameter correctness (for click, type, scroll) + - Bounding box validation (for click) + - Scroll direction validation + - Typed value matching + +**Methods:** +- `apply(cls, lambda_node_dict, state)` - Execute inline evaluation + +**Validation Logic:** +```python +# Tool must match +if predicted_tool != golden_tool: + return False + +# For click: validate coordinates within bounding box +if tool == "click": + validate_bbox(x, y, golden_bbox) + +# For scroll: validate direction +if tool == "scroll": + validate_direction(predicted_direction, golden_direction) + +# For typing: validate text content +if tool == "typing": + validate_text(predicted_text, golden_text) +``` + +#### `RetryFlow` + +Manages retry logic and determines when to retry failed attempts. + +**Methods:** +- `apply(cls, lambda_node_dict, state)` - Determine if retry is needed + +**Retry Conditions:** +- Step evaluation failed +- Retry count < max retries +- No server errors + +#### `ShouldContinueCondition` + +Edge condition to determine if workflow should continue. + +**Methods:** +- `apply(cls, edge_dict, state)` - Check continuation conditions + +#### `Flatten` + +Post-processor that flattens nested retry structure for analysis. + +**Transformation:** +``` +Input: {mission_id: {retry_0: {...}, retry_1: {...}}} +Output: [{mission_id, retry_id: "retry_0", ...}, + {mission_id, retry_id: "retry_1", ...}] +``` + +**Methods:** +- `process(data, metadata)` - Flatten retry structure + +**Output Fields:** +- `id`, `mission_id`, `turn`, `mission`, `navigational_directions` +- `golden_response`, `retry_id`, `model_response` +- `tool_match`, `step_match` + +--- + +### 2. Tools (`tools.py`) + +Browser interaction tools using LangChain's `@tool` decorator. + +#### Available Tools + +| Tool | Description | Parameters | +|------|-------------|------------| +| `screenshot_tool` | Capture current page state | `take_screenshot: bool` | +| `click_tool` | Click at coordinates | `x: float, y: float` | +| `type_tool` | Type at coordinates | `x: float, y: float, text: str` | +| `typing_tool` | Type without coordinates | `text: str` | +| `scroll_tool` | Scroll in direction | `direction: str, amount: float` | +| `wait_tool` | Wait for duration | `time: float` (milliseconds) | +| `resume_tool` | Resume after pause | `resume: bool` | +| `hil_tool` | Human-in-the-loop | `wait_for_human: bool` | +| `text_clear_tool` | Clear text field | `clear_text: bool` | +| `slider_tool` | Move slider | `direction: str, amount: float` | + +#### Tool Usage Example + +```python +# Click at coordinates +click_tool.invoke({"x": 500, "y": 300}) + +# Type text +typing_tool.invoke({"text": "Hello World"}) + +# Scroll down +scroll_tool.invoke({"direction": "down", "amount": 200}) +``` + +--- + +### 3. Constants (`constants.py`) + +Configuration constants organized by category. + +#### Categories + +**Server Error Detection** +- `SERVER_DOWN_ERROR` - Error marker string +- `SERVER_ERROR_MARKERS` - List of error markers + +**Tool Configuration** +- `TOOL_NAME_SUFFIX` - Suffix for tool names ("_tool") +- `TOOL_NAME_MAPPINGS` - Tool name aliases +- `TOOL_TYPE_*` - Tool type constants + +**Retry Configuration** +- `DEFAULT_MAX_RETRIES` - Default retry limit (3) +- `RETRY_KEY_PREFIX` - Prefix for retry keys + +**State Keys** +- `CHAT_HISTORY_STATE_KEY` - Chat history storage key +- `MODEL_RESPONSES_KEY` - Model responses storage key +- `GOLDEN_RESPONSE_KEY` - Golden response key +- `CURRENT_TOOL_RESULT_KEY` - Current tool result key + +**Failure Hints** +- `FAILURE_HINT_TOOL_INCORRECT` - Hint for wrong tool +- `FAILURE_HINT_PARAMS_INCORRECT` - Hint for wrong parameters +- `FAILURE_HINT_RETRY_TEMPLATE` - Template for retry messages + +--- + +### 4. Graph Configuration (`graph_config.yaml`) + +Defines the evaluation workflow and configuration. + +#### Data Configuration + +```yaml +data_config: + source: + type: "disk" + file_path: "tasks/eval/agents/web_agents/chat_history_seed.json" + transformations: + - AddNewFieldTransform # Add supported tools, dimensions + - AddRetryFieldsTransform # Add retry configuration +``` + +> **Note:** The `chat_history_seed.json` file currently contains only sample data with a few records for testing and development purposes. This is not a complete dataset. + +#### Graph Configuration + +**Properties:** +- `chat_conversation: multiturn` - Multi-turn conversation support +- `chat_history_window_size: 1000` - History window size +- `retry_chat_injection` - Retry prompt injection settings + +**Nodes:** +- `fetch_next_action_tools` - Main LLM node for action prediction + +**Lambdas:** +- `inline_evaluation` - Evaluate predictions inline +- `retry_flow` - Manage retry logic + +**Edges:** +- `should_continue` - Conditional edge for workflow control + +#### System Prompt Structure + +The system prompt guides the agent with: +1. **Core Principles** - Think before acting, tool restrictions, trust screenshots +2. **Action Guidelines** - Pop-ups, ads, disabled elements, extraction, retries +3. **Interaction Rules** - Clicks, typing, scrolling, modals, dropdowns, tabs +4. **User Confirmation** - Authentication, sensitive data, destructive actions +5. **Mission Context** - Mission description, navigational directions +6. **Screenshot Specs** - Dimensions, coordinate system + +#### Post-Processors + +**Flatten** +```yaml +post_processors: + - name: tasks.eval.agents.web_agents.task_executor.Flatten +``` + +**MetricCollatorPostProcessor** +```yaml +- name: tasks.eval.utils.MetricCollatorPostProcessor + params: + aggregator_metrics_map: + - name: "accuracy" + unit_metrics_results: ["step_match"] + - name: "pass@k" + params: {k: 3} + unit_metrics_results: ["step_match"] + - name: "pass^k" + params: {k: 3} + unit_metrics_results: ["step_match"] + - name: "step_efficiency" + params: {key: "tool"} + metadata: + mission_id: "mission_id" + step_id: "turn" + retry_id: "retry_id" + unit_metrics_results: ["step_match"] +``` + +--- + +## Evaluation Metrics + +### Unit Metrics (Inline) + +Evaluated during execution: + +1. **Tool Match** - Exact tool name match +2. **Step Match** - Comprehensive step validation: + - Tool correctness + - Parameter validation + - Bounding box validation (click) + - Direction validation (scroll) + - Text matching (typing) + +### Aggregator Metrics (Post-Processing) + +Calculated after execution: + +1. **Accuracy** - Overall success rate +2. **Pass@k** - Probability of success in k attempts + - Returns: `pass@1`, `pass@2`, ..., `pass@k` +3. **Pass^k** - Probability of success in all k attempts + - Returns: `success_rate`, `pass^1`, `pass^2`, ..., `pass^k` +4. **Step Efficiency** - Efficiency based on retry attempts + - Metrics: `step_efficiency`, `first_attempt_correct`, `retry_correct`, `never_correct` + - Penalty per retry: 0.2 (configurable) + +--- + +## Workflow + +### Execution Flow + +``` +1. Load Data (chat_history_seed.json) + ↓ +2. Add Transformations (tools, dimensions, retry fields) + ↓ +3. For each mission/step: + ├─→ FetchNextActionPreProcessor + │ ├─ Manage chat history + │ ├─ Inject retry hints (if retry) + │ └─ Log request + ↓ + ├─→ LLM Node (fetch_next_action_tools) + │ └─ Generate action prediction + ↓ + ├─→ FetchNextActionPostProcessor + │ ├─ Extract tool call + │ ├─ Log response + │ └─ Update state + ↓ + ├─→ InlineEvaluationLambda + │ ├─ Evaluate tool match + │ ├─ Evaluate step match + │ └─ Store results + ↓ + ├─→ RetryFlow + │ └─ Determine if retry needed + ↓ + └─→ ShouldContinueCondition + └─ Check if workflow continues + ↓ +4. Flatten (Post-Processor) + └─ Flatten retry structure + ↓ +5. MetricCollatorPostProcessor + └─ Calculate aggregator metrics +``` + +### Retry Logic + +``` +Initial Attempt (retry_0) + ↓ + Evaluate + ↓ + Failed? → Yes → Inject Failure Hint + ↓ + Retry Attempt (retry_1) + ↓ + Evaluate + ↓ + Failed? → Yes → Inject Failure Hint + ↓ + Retry Attempt (retry_2) + ↓ + Max retries reached → Stop +``` + +**Failure Hints:** +- **Tool Incorrect**: "Do NOT use this tool again. Use a different tool." +- **Parameters Incorrect**: "Use the same tool with correct parameters." + +--- + +## Usage + +### Running Evaluation + +```bash +# Run the web agent evaluation +python -m sygra.cli.run_graph \ + --config tasks/eval/agents/web_agents/graph_config.yaml +``` + +### Input Data Format + +```json +{ + "id": "mission_1_step_1", + "mission_id": "mission_1", + "turn": 1, + "mission": "Book a flight from NYC to LAX", + "navigational_directions": "Click on the search button", + "golden_response": { + "tool": "click", + "x": 500, + "y": 300, + "bbox": {"x": 480, "y": 280, "width": 40, "height": 40} + }, + "chat_history": [...] +} +``` + +### Output Format + +**Flattened Output:** +```json +{ + "id": "mission_1_step_1", + "mission_id": "mission_1", + "turn": 1, + "retry_id": "retry_0", + "model_response": {...}, + "tool_match": {"correct": true, "score": 1.0}, + "step_match": {"correct": true, "score": 1.0} +} +``` + +**Metrics Output:** +```json +{ + "evaluation_summary": { + "total_records": 100, + "timestamp": "2026-03-05 12:00:00", + "status": "success" + }, + "results": { + "step_match-accuracy": 0.85, + "step_match-pass@1": 0.75, + "step_match-pass@2": 0.90, + "step_match-pass@3": 0.95, + "step_match-pass^1": 0.75, + "step_match-pass^2": 0.5625, + "step_match-pass^3": 0.421875, + "step_match-step_efficiency": { + "step_efficiency": 0.82, + "first_attempt_correct": 75, + "retry_correct": 10, + "never_correct": 15 + } + } +} +``` + +--- + +## Configuration + +### Retry Configuration + +```python +# In graph_config.yaml +max_retries: 3 +retry_chat_injection: + required: "yes" + retry_prompt_injection: "yes" +``` + +### Metadata Mapping + +```yaml +# For step_efficiency metric +metadata: + mission_id: "mission_id" # Maps to mission_id field + step_id: "turn" # Maps to turn field + retry_id: "retry_id" # Maps to retry_id field +``` + +### Image Scaling + +```python +IMAGE_SCALE_FACTORS = { + "50_percent": 0.5, + "25_percent": 0.25, + "30_percent": 0.3 +} +``` + +--- + +## Logging + +### Request/Response Logs + +Location: `tasks/eval/agents/web_agents/logs/` + +Format: `web_agent_requests_YYYYMMDD_HHMMSS.json` + +### Log Entry Structure + +```json +{ + "step": 1, + "timestamp": "2026-03-05T12:00:00.000000", + "type": "request", + "payload": { + "messages": [...], + "tools": [...], + "model": "..." + } +} +``` + +--- + +## Error Handling + +### Server Errors + +Detected by `RequestResponseLogger.is_server_error()`: +- Checks for `SERVER_ERROR_MARKERS` in response +- Prevents retry on server errors +- Logs error details + +### Validation Errors + +Handled by inline evaluation: +- Tool mismatch +- Parameter validation failures +- Bounding box violations +- Direction mismatches + +--- + +## Best Practices + +1. **Always log requests/responses** for debugging +2. **Use retry hints** to guide agent corrections +3. **Validate inline** to catch errors early +4. **Configure metadata** for metrics that need context +5. **Monitor step efficiency** to optimize retry strategy +6. **Review logs** when debugging failures + +--- + +## Extending the Module + +### Adding New Tools + +```python +# In tools.py +@tool +def new_tool(param1: type1, param2: type2): + """Tool description. + + Args: + param1: Description + param2: Description + """ + logger.info(f"Executing new_tool: {param1}, {param2}") + return +``` + +### Adding New Metrics + +```yaml +# In graph_config.yaml +- name: "custom_metric" + params: + custom_param: value + metadata: + field1: "source_field1" + unit_metrics_results: + - "step_match" +``` + +### Customizing Retry Logic + +```python +# In task_executor.py +class CustomRetryFlow(LambdaFunction): + @classmethod + def apply(cls, lambda_node_dict: dict, state: SygraState) -> SygraState: + # Custom retry logic + return state +``` + +--- + +## Troubleshooting + +### Common Issues + +**Issue: Metrics not receiving metadata** +- Solution: Ensure metadata mapping is configured in graph_config.yaml + +**Issue: Retry hints not appearing** +- Solution: Check `retry_chat_injection.required` is set to "yes" + +**Issue: Step match always failing** +- Solution: Verify golden response format matches expected structure + +**Issue: Logs not being created** +- Solution: Check logs directory exists and has write permissions + diff --git a/mkdocs.yml b/mkdocs.yml index 35a2ee0a..ad74164c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -56,6 +56,7 @@ nav: - Adding Edges: getting_started/adding_edges.md - Create a Synthetic Datagen Pipeline: getting_started/create_new_pipeline.md - SyGra Studio: getting_started/create_task_ui.md + - Evaluation: eval/README.md - Concepts: - Data Handler: - Overview: concepts/data_handler/README.md @@ -98,6 +99,14 @@ nav: - SyGra Library: - API Reference: library/sygra_library.md - Examples: library/sygra_library_examples.md + - Evaluation: + - Overview: eval/README.md + - Metric: + - Overview: eval/metrics/README.md + - Unit Metrics: eval/metrics/unit_metrics_summary.md + - Aggregator Metrics: eval/metrics/aggregator_metrics_summary.md + - Agents: + - Web Agents Evaluation: eval/agents/web_agents_eval.md - Contribute: development.md plugins: - search diff --git a/studio/frontend/package-lock.json b/studio/frontend/package-lock.json index 22fcf02a..b3453b10 100644 --- a/studio/frontend/package-lock.json +++ b/studio/frontend/package-lock.json @@ -1,8 +1,12 @@ { - "lockfileVersion": 3, "name": "sygra-workflow-ui", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, "packages": { "": { + "name": "sygra-workflow-ui", + "version": "0.1.0", "dependencies": { "@monaco-editor/loader": "^1.4.0", "@xyflow/svelte": "^0.1.22", @@ -27,476 +31,478 @@ "tailwindcss": "^3.4.17", "typescript": "^5.7.2", "vite": "^5.4.0" - }, - "name": "sygra-workflow-ui", - "version": "0.1.0" + } }, "node_modules/@alloc/quick-lru": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", - "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", - "version": "5.2.0" + } }, "node_modules/@babel/runtime": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz", + "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==", "engines": { "node": ">=6.9.0" - }, - "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz", - "version": "7.28.4" + } }, "node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", "cpu": [ "ppc64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", "optional": true, "os": [ "aix" ], - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", "cpu": [ "arm" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", "optional": true, "os": [ "android" ], - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", "cpu": [ "arm64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", "optional": true, "os": [ "android" ], - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", "optional": true, "os": [ "android" ], - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", "cpu": [ "arm64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", "optional": true, "os": [ "darwin" ], - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", "optional": true, "os": [ "darwin" ], - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", "cpu": [ "arm64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", "optional": true, "os": [ "freebsd" ], - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", "optional": true, "os": [ "freebsd" ], - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", "cpu": [ "arm" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", "cpu": [ "arm64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", "cpu": [ "ia32" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", "cpu": [ "loong64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", "cpu": [ "mips64el" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", "cpu": [ "ppc64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", "cpu": [ "riscv64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", "cpu": [ "s390x" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", "optional": true, "os": [ "linux" ], - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", "optional": true, "os": [ "netbsd" ], - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", "optional": true, "os": [ "openbsd" ], - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", "optional": true, "os": [ "sunos" ], - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", "cpu": [ "arm64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", "optional": true, "os": [ "win32" ], - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", "cpu": [ "ia32" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", "optional": true, "os": [ "win32" ], - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", "cpu": [ "x64" ], "dev": true, - "engines": { - "node": ">=12" - }, - "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", "optional": true, "os": [ "win32" ], - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", - "version": "0.21.5" + "engines": { + "node": ">=12" + } }, "node_modules/@eslint-community/eslint-utils": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz", + "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==", + "dev": true, "dependencies": { "eslint-visitor-keys": "^3.4.3" }, - "dev": true, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, "funding": { "url": "https://opencollective.com/eslint" }, - "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==", "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" - }, - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz", - "version": "4.9.0" + } }, "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, "funding": { "url": "https://opencollective.com/eslint" - }, - "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", - "version": "3.4.3" + } }, "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", "dev": true, "engines": { "node": "^12.0.0 || ^14.0.0 || >=16.0.0" - }, - "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", - "version": "4.12.2" + } }, "node_modules/@eslint/config-array": { + "version": "0.21.1", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz", + "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==", + "dev": true, "dependencies": { "@eslint/object-schema": "^2.1.7", "debug": "^4.3.1", "minimatch": "^3.1.2" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" - }, - "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==", - "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz", - "version": "0.21.1" + } }, "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, "dependencies": { "@eslint/core": "^0.17.0" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" - }, - "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", - "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", - "version": "0.4.2" + } }, "node_modules/@eslint/core": { - "dependencies": { - "@types/json-schema": "^7.0.15" - }, + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", "dev": true, + "dependencies": { + "@types/json-schema": "^7.0.15" + }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" - }, - "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", - "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", - "version": "0.17.0" + } }, "node_modules/@eslint/eslintrc": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz", + "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==", + "dev": true, "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", @@ -508,74 +514,73 @@ "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://opencollective.com/eslint" - }, - "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz", - "version": "3.3.3" + } }, "node_modules/@eslint/js": { + "version": "9.39.2", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz", + "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==", "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://eslint.org/donate" - }, - "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz", - "version": "9.39.2" + } }, "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" - }, - "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", - "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", - "version": "2.1.7" + } }, "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, "dependencies": { "@eslint/core": "^0.17.0", "levn": "^0.4.1" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" - }, - "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", - "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", - "version": "0.4.1" + } }, "node_modules/@humanfs/core": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", + "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", "dev": true, "engines": { "node": ">=18.18.0" - }, - "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", - "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", - "version": "0.19.1" + } }, "node_modules/@humanfs/node": { + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", + "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", + "dev": true, "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.4.0" }, - "dev": true, "engines": { "node": ">=18.18.0" - }, - "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", - "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", - "version": "0.16.7" + } }, "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", "dev": true, "engines": { "node": ">=12.22" @@ -583,12 +588,12 @@ "funding": { "type": "github", "url": "https://github.com/sponsors/nzakas" - }, - "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", - "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", - "version": "1.0.1" + } }, "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", "dev": true, "engines": { "node": ">=18.18" @@ -596,427 +601,425 @@ "funding": { "type": "github", "url": "https://github.com/sponsors/nzakas" - }, - "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", - "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", - "version": "0.4.3" + } }, "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" - }, - "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", - "version": "0.3.13" + } }, "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" - }, - "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", - "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", - "version": "2.3.5" + } }, "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "engines": { "node": ">=6.0.0" - }, - "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", - "version": "3.1.2" + } }, "node_modules/@jridgewell/sourcemap-codec": { - "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "version": "1.5.5", "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", - "version": "1.5.5" + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==" }, "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" - }, - "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", - "version": "0.3.31" + } }, "node_modules/@kurkle/color": { - "integrity": "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w==", - "license": "MIT", + "version": "0.3.4", "resolved": "https://registry.npmjs.org/@kurkle/color/-/color-0.3.4.tgz", - "version": "0.3.4" + "integrity": "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w==", + "license": "MIT" }, "node_modules/@monaco-editor/loader": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/@monaco-editor/loader/-/loader-1.7.0.tgz", + "integrity": "sha512-gIwR1HrJrrx+vfyOhYmCZ0/JcWqG5kbfG7+d3f/C1LXk2EvzAbHSg3MQ5lO2sMlo9izoAZ04shohfKLVT6crVA==", "dependencies": { "state-local": "^1.0.6" - }, - "integrity": "sha512-gIwR1HrJrrx+vfyOhYmCZ0/JcWqG5kbfG7+d3f/C1LXk2EvzAbHSg3MQ5lO2sMlo9izoAZ04shohfKLVT6crVA==", - "resolved": "https://registry.npmjs.org/@monaco-editor/loader/-/loader-1.7.0.tgz", - "version": "1.7.0" + } }, "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" }, - "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "version": "2.1.5" + } }, "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "version": "2.0.5" + } }, "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" }, - "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "version": "1.2.8" + } }, "node_modules/@polka/url": { - "dev": true, - "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==", + "version": "1.0.0-next.29", "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.29.tgz", - "version": "1.0.0-next.29" + "integrity": "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==", + "dev": true }, "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.5.tgz", + "integrity": "sha512-iDGS/h7D8t7tvZ1t6+WPK04KD0MwzLZrG0se1hzBjSi5fyxlsiggoJHwh18PCFNn7tG43OWb6pdZ6Y+rMlmyNQ==", "cpu": [ "arm" ], "dev": true, - "integrity": "sha512-iDGS/h7D8t7tvZ1t6+WPK04KD0MwzLZrG0se1hzBjSi5fyxlsiggoJHwh18PCFNn7tG43OWb6pdZ6Y+rMlmyNQ==", "optional": true, "os": [ "android" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-android-arm64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.5.tgz", + "integrity": "sha512-wrSAViWvZHBMMlWk6EJhvg8/rjxzyEhEdgfMMjREHEq11EtJ6IP6yfcCH57YAEca2Oe3FNCE9DSTgU70EIGmVw==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-wrSAViWvZHBMMlWk6EJhvg8/rjxzyEhEdgfMMjREHEq11EtJ6IP6yfcCH57YAEca2Oe3FNCE9DSTgU70EIGmVw==", "optional": true, "os": [ "android" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.5.tgz", + "integrity": "sha512-S87zZPBmRO6u1YXQLwpveZm4JfPpAa6oHBX7/ghSiGH3rz/KDgAu1rKdGutV+WUI6tKDMbaBJomhnT30Y2t4VQ==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-S87zZPBmRO6u1YXQLwpveZm4JfPpAa6oHBX7/ghSiGH3rz/KDgAu1rKdGutV+WUI6tKDMbaBJomhnT30Y2t4VQ==", "optional": true, "os": [ "darwin" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.5.tgz", + "integrity": "sha512-YTbnsAaHo6VrAczISxgpTva8EkfQus0VPEVJCEaboHtZRIb6h6j0BNxRBOwnDciFTZLDPW5r+ZBmhL/+YpTZgA==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-YTbnsAaHo6VrAczISxgpTva8EkfQus0VPEVJCEaboHtZRIb6h6j0BNxRBOwnDciFTZLDPW5r+ZBmhL/+YpTZgA==", "optional": true, "os": [ "darwin" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.5.tgz", + "integrity": "sha512-1T8eY2J8rKJWzaznV7zedfdhD1BqVs1iqILhmHDq/bqCUZsrMt+j8VCTHhP0vdfbHK3e1IQ7VYx3jlKqwlf+vw==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-1T8eY2J8rKJWzaznV7zedfdhD1BqVs1iqILhmHDq/bqCUZsrMt+j8VCTHhP0vdfbHK3e1IQ7VYx3jlKqwlf+vw==", "optional": true, "os": [ "freebsd" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.5.tgz", + "integrity": "sha512-sHTiuXyBJApxRn+VFMaw1U+Qsz4kcNlxQ742snICYPrY+DDL8/ZbaC4DVIB7vgZmp3jiDaKA0WpBdP0aqPJoBQ==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-sHTiuXyBJApxRn+VFMaw1U+Qsz4kcNlxQ742snICYPrY+DDL8/ZbaC4DVIB7vgZmp3jiDaKA0WpBdP0aqPJoBQ==", "optional": true, "os": [ "freebsd" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.5.tgz", + "integrity": "sha512-dV3T9MyAf0w8zPVLVBptVlzaXxka6xg1f16VAQmjg+4KMSTWDvhimI/Y6mp8oHwNrmnmVl9XxJ/w/mO4uIQONA==", "cpu": [ "arm" ], "dev": true, - "integrity": "sha512-dV3T9MyAf0w8zPVLVBptVlzaXxka6xg1f16VAQmjg+4KMSTWDvhimI/Y6mp8oHwNrmnmVl9XxJ/w/mO4uIQONA==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.5.tgz", + "integrity": "sha512-wIGYC1x/hyjP+KAu9+ewDI+fi5XSNiUi9Bvg6KGAh2TsNMA3tSEs+Sh6jJ/r4BV/bx/CyWu2ue9kDnIdRyafcQ==", "cpu": [ "arm" ], "dev": true, - "integrity": "sha512-wIGYC1x/hyjP+KAu9+ewDI+fi5XSNiUi9Bvg6KGAh2TsNMA3tSEs+Sh6jJ/r4BV/bx/CyWu2ue9kDnIdRyafcQ==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.5.tgz", + "integrity": "sha512-Y+qVA0D9d0y2FRNiG9oM3Hut/DgODZbU9I8pLLPwAsU0tUKZ49cyV1tzmB/qRbSzGvY8lpgGkJuMyuhH7Ma+Vg==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-Y+qVA0D9d0y2FRNiG9oM3Hut/DgODZbU9I8pLLPwAsU0tUKZ49cyV1tzmB/qRbSzGvY8lpgGkJuMyuhH7Ma+Vg==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.5.tgz", + "integrity": "sha512-juaC4bEgJsyFVfqhtGLz8mbopaWD+WeSOYr5E16y+1of6KQjc0BpwZLuxkClqY1i8sco+MdyoXPNiCkQou09+g==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-juaC4bEgJsyFVfqhtGLz8mbopaWD+WeSOYr5E16y+1of6KQjc0BpwZLuxkClqY1i8sco+MdyoXPNiCkQou09+g==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.5.tgz", + "integrity": "sha512-rIEC0hZ17A42iXtHX+EPJVL/CakHo+tT7W0pbzdAGuWOt2jxDFh7A/lRhsNHBcqL4T36+UiAgwO8pbmn3dE8wA==", "cpu": [ "loong64" ], "dev": true, - "integrity": "sha512-rIEC0hZ17A42iXtHX+EPJVL/CakHo+tT7W0pbzdAGuWOt2jxDFh7A/lRhsNHBcqL4T36+UiAgwO8pbmn3dE8wA==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.5.tgz", + "integrity": "sha512-T7l409NhUE552RcAOcmJHj3xyZ2h7vMWzcwQI0hvn5tqHh3oSoclf9WgTl+0QqffWFG8MEVZZP1/OBglKZx52Q==", "cpu": [ "ppc64" ], "dev": true, - "integrity": "sha512-T7l409NhUE552RcAOcmJHj3xyZ2h7vMWzcwQI0hvn5tqHh3oSoclf9WgTl+0QqffWFG8MEVZZP1/OBglKZx52Q==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.5.tgz", + "integrity": "sha512-7OK5/GhxbnrMcxIFoYfhV/TkknarkYC1hqUw1wU2xUN3TVRLNT5FmBv4KkheSG2xZ6IEbRAhTooTV2+R5Tk0lQ==", "cpu": [ "riscv64" ], "dev": true, - "integrity": "sha512-7OK5/GhxbnrMcxIFoYfhV/TkknarkYC1hqUw1wU2xUN3TVRLNT5FmBv4KkheSG2xZ6IEbRAhTooTV2+R5Tk0lQ==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.5.tgz", + "integrity": "sha512-GwuDBE/PsXaTa76lO5eLJTyr2k8QkPipAyOrs4V/KJufHCZBJ495VCGJol35grx9xryk4V+2zd3Ri+3v7NPh+w==", "cpu": [ "riscv64" ], "dev": true, - "integrity": "sha512-GwuDBE/PsXaTa76lO5eLJTyr2k8QkPipAyOrs4V/KJufHCZBJ495VCGJol35grx9xryk4V+2zd3Ri+3v7NPh+w==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.5.tgz", + "integrity": "sha512-IAE1Ziyr1qNfnmiQLHBURAD+eh/zH1pIeJjeShleII7Vj8kyEm2PF77o+lf3WTHDpNJcu4IXJxNO0Zluro8bOw==", "cpu": [ "s390x" ], "dev": true, - "integrity": "sha512-IAE1Ziyr1qNfnmiQLHBURAD+eh/zH1pIeJjeShleII7Vj8kyEm2PF77o+lf3WTHDpNJcu4IXJxNO0Zluro8bOw==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.5.tgz", + "integrity": "sha512-Pg6E+oP7GvZ4XwgRJBuSXZjcqpIW3yCBhK4BcsANvb47qMvAbCjR6E+1a/U2WXz1JJxp9/4Dno3/iSJLcm5auw==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-Pg6E+oP7GvZ4XwgRJBuSXZjcqpIW3yCBhK4BcsANvb47qMvAbCjR6E+1a/U2WXz1JJxp9/4Dno3/iSJLcm5auw==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.5.tgz", + "integrity": "sha512-txGtluxDKTxaMDzUduGP0wdfng24y1rygUMnmlUJ88fzCCULCLn7oE5kb2+tRB+MWq1QDZT6ObT5RrR8HFRKqg==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-txGtluxDKTxaMDzUduGP0wdfng24y1rygUMnmlUJ88fzCCULCLn7oE5kb2+tRB+MWq1QDZT6ObT5RrR8HFRKqg==", "optional": true, "os": [ "linux" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.5.tgz", + "integrity": "sha512-3DFiLPnTxiOQV993fMc+KO8zXHTcIjgaInrqlG8zDp1TlhYl6WgrOHuJkJQ6M8zHEcntSJsUp1XFZSY8C1DYbg==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-3DFiLPnTxiOQV993fMc+KO8zXHTcIjgaInrqlG8zDp1TlhYl6WgrOHuJkJQ6M8zHEcntSJsUp1XFZSY8C1DYbg==", "optional": true, "os": [ "openharmony" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.5.tgz", + "integrity": "sha512-nggc/wPpNTgjGg75hu+Q/3i32R00Lq1B6N1DO7MCU340MRKL3WZJMjA9U4K4gzy3dkZPXm9E1Nc81FItBVGRlA==", "cpu": [ "arm64" ], "dev": true, - "integrity": "sha512-nggc/wPpNTgjGg75hu+Q/3i32R00Lq1B6N1DO7MCU340MRKL3WZJMjA9U4K4gzy3dkZPXm9E1Nc81FItBVGRlA==", "optional": true, "os": [ "win32" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.5.tgz", + "integrity": "sha512-U/54pTbdQpPLBdEzCT6NBCFAfSZMvmjr0twhnD9f4EIvlm9wy3jjQ38yQj1AGznrNO65EWQMgm/QUjuIVrYF9w==", "cpu": [ "ia32" ], "dev": true, - "integrity": "sha512-U/54pTbdQpPLBdEzCT6NBCFAfSZMvmjr0twhnD9f4EIvlm9wy3jjQ38yQj1AGznrNO65EWQMgm/QUjuIVrYF9w==", "optional": true, "os": [ "win32" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.5.tgz", + "integrity": "sha512-2NqKgZSuLH9SXBBV2dWNRCZmocgSOx8OJSdpRaEcRlIfX8YrKxUT6z0F1NpvDVhOsl190UFTRh2F2WDWWCYp3A==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-2NqKgZSuLH9SXBBV2dWNRCZmocgSOx8OJSdpRaEcRlIfX8YrKxUT6z0F1NpvDVhOsl190UFTRh2F2WDWWCYp3A==", "optional": true, "os": [ "win32" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.5.tgz", + "integrity": "sha512-JRpZUhCfhZ4keB5v0fe02gQJy05GqboPOaxvjugW04RLSYYoB/9t2lx2u/tMs/Na/1NXfY8QYjgRljRpN+MjTQ==", "cpu": [ "x64" ], "dev": true, - "integrity": "sha512-JRpZUhCfhZ4keB5v0fe02gQJy05GqboPOaxvjugW04RLSYYoB/9t2lx2u/tMs/Na/1NXfY8QYjgRljRpN+MjTQ==", "optional": true, "os": [ "win32" - ], - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.5.tgz", - "version": "4.53.5" + ] }, "node_modules/@standard-schema/spec": { - "dev": true, - "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "version": "1.1.0", "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", - "version": "1.1.0" + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "dev": true }, "node_modules/@svelte-put/shortcut": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@svelte-put/shortcut/-/shortcut-3.2.0.tgz", "integrity": "sha512-3VFU6TX4DwXT7vrtKGqwWa5WqEsFWQVZMSffE0owCwKUIBAhjGtZGy69G4+2quGhl/r+qi4jLrXkE00xw38M7g==", "peerDependencies": { "svelte": "^3.55.0 || ^4.0.0 || ^5.0.0" - }, - "resolved": "https://registry.npmjs.org/@svelte-put/shortcut/-/shortcut-3.2.0.tgz", - "version": "3.2.0" + } }, "node_modules/@sveltejs/acorn-typescript": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.8.tgz", "integrity": "sha512-esgN+54+q0NjB0Y/4BomT9samII7jGwNy/2a3wNZbT2A2RpmXsXwUt24LvLhx6jUq2gVk4cWEvcRO6MFQbOfNA==", "peerDependencies": { "acorn": "^8.9.0" - }, - "resolved": "https://registry.npmjs.org/@sveltejs/acorn-typescript/-/acorn-typescript-1.0.8.tgz", - "version": "1.0.8" + } }, "node_modules/@sveltejs/adapter-static": { - "dev": true, + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@sveltejs/adapter-static/-/adapter-static-3.0.10.tgz", "integrity": "sha512-7D9lYFWJmB7zxZyTE/qxjksvMqzMuYrrsyh1f4AlZqeZeACPRySjbC3aFiY55wb1tWUaKOQG9PVbm74JcN2Iew==", + "dev": true, "peerDependencies": { "@sveltejs/kit": "^2.0.0" - }, - "resolved": "https://registry.npmjs.org/@sveltejs/adapter-static/-/adapter-static-3.0.10.tgz", - "version": "3.0.10" + } }, "node_modules/@sveltejs/kit": { - "bin": { - "svelte-kit": "svelte-kit.js" - }, + "version": "2.49.2", + "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.49.2.tgz", + "integrity": "sha512-Vp3zX/qlwerQmHMP6x0Ry1oY7eKKRcOWGc2P59srOp4zcqyn+etJyQpELgOi4+ZSUgteX8Y387NuwruLgGXLUQ==", + "dev": true, "dependencies": { "@standard-schema/spec": "^1.0.0", "@sveltejs/acorn-typescript": "^1.0.5", @@ -1032,11 +1035,12 @@ "set-cookie-parser": "^2.6.0", "sirv": "^3.0.0" }, - "dev": true, + "bin": { + "svelte-kit": "svelte-kit.js" + }, "engines": { "node": ">=18.13" }, - "integrity": "sha512-Vp3zX/qlwerQmHMP6x0Ry1oY7eKKRcOWGc2P59srOp4zcqyn+etJyQpELgOi4+ZSUgteX8Y387NuwruLgGXLUQ==", "peerDependencies": { "@opentelemetry/api": "^1.0.0", "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0", @@ -1047,11 +1051,13 @@ "@opentelemetry/api": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.49.2.tgz", - "version": "2.49.2" + } }, "node_modules/@sveltejs/vite-plugin-svelte": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-4.0.4.tgz", + "integrity": "sha512-0ba1RQ/PHen5FGpdSrW7Y3fAMQjrXantECALeOiOdBdzR5+5vPP6HVZRLmZaQL+W8m++o+haIAKq5qT+MiZ7VA==", + "dev": true, "dependencies": { "@sveltejs/vite-plugin-svelte-inspector": "^3.0.0-next.0||^3.0.0", "debug": "^4.3.7", @@ -1060,135 +1066,134 @@ "magic-string": "^0.30.12", "vitefu": "^1.0.3" }, - "dev": true, "engines": { "node": "^18.0.0 || ^20.0.0 || >=22" }, - "integrity": "sha512-0ba1RQ/PHen5FGpdSrW7Y3fAMQjrXantECALeOiOdBdzR5+5vPP6HVZRLmZaQL+W8m++o+haIAKq5qT+MiZ7VA==", "peerDependencies": { "svelte": "^5.0.0-next.96 || ^5.0.0", "vite": "^5.0.0" - }, - "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte/-/vite-plugin-svelte-4.0.4.tgz", - "version": "4.0.4" + } }, "node_modules/@sveltejs/vite-plugin-svelte-inspector": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-3.0.1.tgz", + "integrity": "sha512-2CKypmj1sM4GE7HjllT7UKmo4Q6L5xFRd7VMGEWhYnZ+wc6AUVU01IBd7yUi6WnFndEwWoMNOd6e8UjoN0nbvQ==", + "dev": true, "dependencies": { "debug": "^4.3.7" }, - "dev": true, "engines": { "node": "^18.0.0 || ^20.0.0 || >=22" }, - "integrity": "sha512-2CKypmj1sM4GE7HjllT7UKmo4Q6L5xFRd7VMGEWhYnZ+wc6AUVU01IBd7yUi6WnFndEwWoMNOd6e8UjoN0nbvQ==", "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^4.0.0-next.0||^4.0.0", "svelte": "^5.0.0-next.96 || ^5.0.0", "vite": "^5.0.0" - }, - "resolved": "https://registry.npmjs.org/@sveltejs/vite-plugin-svelte-inspector/-/vite-plugin-svelte-inspector-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/@types/cookie": { - "dev": true, - "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==", + "version": "0.6.0", "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.6.0.tgz", - "version": "0.6.0" + "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==", + "dev": true }, "node_modules/@types/d3-color": { - "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "version": "3.1.3", "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", - "version": "3.1.3" + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==" }, "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", "dependencies": { "@types/d3-selection": "*" - }, - "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", - "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", - "version": "3.0.7" + } }, "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", "dependencies": { "@types/d3-color": "*" - }, - "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", - "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", - "version": "3.0.4" + } }, "node_modules/@types/d3-selection": { - "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "version": "3.0.11", "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", - "version": "3.0.11" + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==" }, "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", "dependencies": { "@types/d3-selection": "*" - }, - "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", - "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", - "version": "3.0.9" + } }, "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", "dependencies": { "@types/d3-interpolate": "*", "@types/d3-selection": "*" - }, - "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", - "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", - "version": "3.0.8" + } }, "node_modules/@types/estree": { - "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "version": "1.0.8", "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", - "version": "1.0.8" + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==" }, "node_modules/@types/json-schema": { - "dev": true, - "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "version": "7.0.15", "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", - "version": "7.0.15" + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "dev": true }, "node_modules/@types/node": { + "version": "22.19.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.3.tgz", + "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==", + "dev": true, "dependencies": { "undici-types": "~6.21.0" - }, - "dev": true, - "integrity": "sha512-1N9SBnWYOJTrNZCdh/yJE+t910Y128BoyY+zBLWhL3r0TYzlTmFdXrPwHL9DyFZmlEXNQQolTZh3KHV31QDhyA==", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.3.tgz", - "version": "22.19.3" + } }, "node_modules/@types/pako": { - "integrity": "sha512-VWDCbrLeVXJM9fihYodcLiIv0ku+AlOa/TQ1SvYOaBuyrSKgEcro95LJyIsJ4vSo6BXIxOKxiJAat04CmST9Fw==", + "version": "2.0.4", "resolved": "https://registry.npmjs.org/@types/pako/-/pako-2.0.4.tgz", - "version": "2.0.4" + "integrity": "sha512-VWDCbrLeVXJM9fihYodcLiIv0ku+AlOa/TQ1SvYOaBuyrSKgEcro95LJyIsJ4vSo6BXIxOKxiJAat04CmST9Fw==" }, "node_modules/@types/raf": { - "integrity": "sha512-c4YAvMedbPZ5tEyxzQdMoOhhJ4RD3rngZIdwC2/qDN3d7JpEhB6fiBRKVY1lg5B7Wk+uPBjn5f39j1/2MY1oOw==", - "optional": true, + "version": "3.4.3", "resolved": "https://registry.npmjs.org/@types/raf/-/raf-3.4.3.tgz", - "version": "3.4.3" + "integrity": "sha512-c4YAvMedbPZ5tEyxzQdMoOhhJ4RD3rngZIdwC2/qDN3d7JpEhB6fiBRKVY1lg5B7Wk+uPBjn5f39j1/2MY1oOw==", + "optional": true }, "node_modules/@types/trusted-types": { - "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", - "optional": true, + "version": "2.0.7", "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", - "version": "2.0.7" + "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", + "optional": true }, "node_modules/@xyflow/svelte": { + "version": "0.1.22", + "resolved": "https://registry.npmjs.org/@xyflow/svelte/-/svelte-0.1.22.tgz", + "integrity": "sha512-qFPPYcQHoltdbwb0T6FioSSNzTrCzRkLePIXLGPWFgvy6yk1bL35ztCUYvxrqmIWG42JMDFmFHOP3AyswHTInw==", "dependencies": { "@svelte-put/shortcut": "^3.1.0", "@xyflow/system": "0.0.44", "classcat": "^5.0.4" }, - "integrity": "sha512-qFPPYcQHoltdbwb0T6FioSSNzTrCzRkLePIXLGPWFgvy6yk1bL35ztCUYvxrqmIWG42JMDFmFHOP3AyswHTInw==", "peerDependencies": { "svelte": "^3.0.0 || ^4.0.0 || ^5.0.0" - }, - "resolved": "https://registry.npmjs.org/@xyflow/svelte/-/svelte-0.1.22.tgz", - "version": "0.1.22" + } }, "node_modules/@xyflow/system": { + "version": "0.0.44", + "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.44.tgz", + "integrity": "sha512-hKHtH8hUVKmCCXbTdEYUWNqRkcSBwYxdzZhIxpJst60AEnlobfphNu8eAOJArEJJl+MrjidvY5K/BOzYUcwCug==", "dependencies": { "@types/d3-drag": "^3.0.7", "@types/d3-selection": "^3.0.10", @@ -1197,128 +1202,115 @@ "d3-drag": "^3.0.0", "d3-selection": "^3.0.0", "d3-zoom": "^3.0.0" - }, - "integrity": "sha512-hKHtH8hUVKmCCXbTdEYUWNqRkcSBwYxdzZhIxpJst60AEnlobfphNu8eAOJArEJJl+MrjidvY5K/BOzYUcwCug==", - "resolved": "https://registry.npmjs.org/@xyflow/system/-/system-0.0.44.tgz", - "version": "0.0.44" + } }, "node_modules/acorn": { + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "bin": { "acorn": "bin/acorn" }, "engines": { "node": ">=0.4.0" - }, - "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", - "version": "8.15.0" + } }, "node_modules/acorn-jsx": { - "dev": true, + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "dev": true, "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" - }, - "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", - "version": "5.3.2" + } }, "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" }, - "dev": true, "funding": { "type": "github", "url": "https://github.com/sponsors/epoberezkin" - }, - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "version": "6.12.6" + } }, "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, "dependencies": { "color-convert": "^2.0.1" }, - "dev": true, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/chalk/ansi-styles?sponsor=1" - }, - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "version": "4.3.0" + } }, "node_modules/any-promise": { - "dev": true, - "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "version": "1.3.0", "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", - "version": "1.3.0" + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "dev": true }, "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, "dependencies": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" }, - "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", - "version": "3.1.3" + } }, "node_modules/anymatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", "dev": true, "engines": { "node": ">=8.6" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" - }, - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "version": "2.3.1" + } }, "node_modules/arg": { - "dev": true, - "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "version": "5.0.2", "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", - "version": "5.0.2" + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "dev": true }, "node_modules/argparse": { - "dev": true, - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "version": "2.0.1", "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "version": "2.0.1" + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true }, "node_modules/aria-query": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz", + "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==", "engines": { "node": ">= 0.4" - }, - "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==", - "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz", - "version": "5.3.2" + } }, "node_modules/autoprefixer": { - "bin": { - "autoprefixer": "bin/autoprefixer" - }, - "dependencies": { - "browserslist": "^4.28.1", - "caniuse-lite": "^1.0.30001760", - "fraction.js": "^5.3.4", - "picocolors": "^1.1.1", - "postcss-value-parser": "^4.2.0" - }, + "version": "10.4.23", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.23.tgz", + "integrity": "sha512-YYTXSFulfwytnjAPlw8QHncHJmlvFKtczb8InXaAx9Q0LbfDnfEYDE55omerIJKihhmU61Ft+cAOSzQVaBUmeA==", "dev": true, - "engines": { - "node": "^10 || ^12 || >=14" - }, "funding": [ { "type": "opencollective", @@ -1333,93 +1325,93 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-YYTXSFulfwytnjAPlw8QHncHJmlvFKtczb8InXaAx9Q0LbfDnfEYDE55omerIJKihhmU61Ft+cAOSzQVaBUmeA==", + "dependencies": { + "browserslist": "^4.28.1", + "caniuse-lite": "^1.0.30001760", + "fraction.js": "^5.3.4", + "picocolors": "^1.1.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, "peerDependencies": { "postcss": "^8.1.0" - }, - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.23.tgz", - "version": "10.4.23" + } }, "node_modules/axobject-query": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", + "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", "engines": { "node": ">= 0.4" - }, - "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", - "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", - "version": "4.1.0" + } }, "node_modules/balanced-match": { - "dev": true, - "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "version": "1.0.2", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", - "version": "1.0.2" + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true }, "node_modules/base64-arraybuffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz", + "integrity": "sha512-I3yl4r9QB5ZRY3XuJVEPfc2XhZO6YweFPI+UovAzn+8/hb3oJ6lnysaFcjVpkCPfVWFUDvoZ8kmVDP7WyRtYtQ==", "engines": { "node": ">= 0.6.0" - }, - "integrity": "sha512-I3yl4r9QB5ZRY3XuJVEPfc2XhZO6YweFPI+UovAzn+8/hb3oJ6lnysaFcjVpkCPfVWFUDvoZ8kmVDP7WyRtYtQ==", - "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz", - "version": "1.0.2" + } }, "node_modules/baseline-browser-mapping": { + "version": "2.9.8", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.8.tgz", + "integrity": "sha512-Y1fOuNDowLfgKOypdc9SPABfoWXuZHBOyCS4cD52IeZBhr4Md6CLLs6atcxVrzRmQ06E7hSlm5bHHApPKR/byA==", + "dev": true, "bin": { "baseline-browser-mapping": "dist/cli.js" - }, - "dev": true, - "integrity": "sha512-Y1fOuNDowLfgKOypdc9SPABfoWXuZHBOyCS4cD52IeZBhr4Md6CLLs6atcxVrzRmQ06E7hSlm5bHHApPKR/byA==", - "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.8.tgz", - "version": "2.9.8" + } }, "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", "dev": true, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", - "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", - "version": "2.3.0" + } }, "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" - }, - "dev": true, - "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", - "version": "1.1.12" + } }, "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, "dependencies": { "fill-range": "^7.1.1" }, - "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", - "version": "3.0.3" + } }, "node_modules/browserslist": { - "bin": { - "browserslist": "cli.js" - }, - "dependencies": { - "baseline-browser-mapping": "^2.9.0", - "caniuse-lite": "^1.0.30001759", - "electron-to-chromium": "^1.5.263", - "node-releases": "^2.0.27", - "update-browserslist-db": "^1.2.0" - }, + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", "dev": true, - "engines": { - "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" - }, "funding": [ { "type": "opencollective", @@ -1434,29 +1426,42 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", - "version": "4.28.1" + "dependencies": { + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } }, "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", - "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", - "version": "3.1.0" + } }, "node_modules/camelcase-css": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", - "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", - "version": "2.0.1" + } }, "node_modules/caniuse-lite": { + "version": "1.0.30001760", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001760.tgz", + "integrity": "sha512-7AAMPcueWELt1p3mi13HR/LHH0TJLT11cnwDJEs3xA4+CK/PLKeO9Kl1oru24htkyUKtkGCvAx4ohB0Ttry8Dw==", "dev": true, "funding": [ { @@ -1471,12 +1476,13 @@ "type": "github", "url": "https://github.com/sponsors/ai" } - ], - "integrity": "sha512-7AAMPcueWELt1p3mi13HR/LHH0TJLT11cnwDJEs3xA4+CK/PLKeO9Kl1oru24htkyUKtkGCvAx4ohB0Ttry8Dw==", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001760.tgz", - "version": "1.0.30001760" + ] }, "node_modules/canvg": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/canvg/-/canvg-3.0.11.tgz", + "integrity": "sha512-5ON+q7jCTgMp9cjpu4Jo6XbvfYwSB2Ow3kzHKfIyJfaCAOHLbdKPQqGKgfED/R5B+3TFFfe8pegYA+b423SRyA==", + "optional": true, "dependencies": { "@babel/runtime": "^7.12.5", "@types/raf": "^3.4.0", @@ -1489,241 +1495,240 @@ }, "engines": { "node": ">=10.0.0" - }, - "integrity": "sha512-5ON+q7jCTgMp9cjpu4Jo6XbvfYwSB2Ow3kzHKfIyJfaCAOHLbdKPQqGKgfED/R5B+3TFFfe8pegYA+b423SRyA==", - "optional": true, - "resolved": "https://registry.npmjs.org/canvg/-/canvg-3.0.11.tgz", - "version": "3.0.11" + } }, "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" }, - "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/chalk/chalk?sponsor=1" - }, - "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", - "version": "4.1.2" + } }, "node_modules/chart.js": { + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/chart.js/-/chart.js-4.5.1.tgz", + "integrity": "sha512-GIjfiT9dbmHRiYi6Nl2yFCq7kkwdkp1W/lp2J99rX0yo9tgJGn3lKQATztIjb5tVtevcBtIdICNWqlq5+E8/Pw==", + "license": "MIT", "dependencies": { "@kurkle/color": "^0.3.0" }, "engines": { "pnpm": ">=8" - }, - "integrity": "sha512-GIjfiT9dbmHRiYi6Nl2yFCq7kkwdkp1W/lp2J99rX0yo9tgJGn3lKQATztIjb5tVtevcBtIdICNWqlq5+E8/Pw==", - "license": "MIT", - "resolved": "https://registry.npmjs.org/chart.js/-/chart.js-4.5.1.tgz", - "version": "4.5.1" + } }, "node_modules/chokidar": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", + "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", + "dev": true, "dependencies": { "readdirp": "^4.0.1" }, - "dev": true, "engines": { "node": ">= 14.16.0" }, "funding": { "url": "https://paulmillr.com/funding/" - }, - "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==", - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz", - "version": "4.0.3" + } }, "node_modules/classcat": { - "integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==", + "version": "5.0.5", "resolved": "https://registry.npmjs.org/classcat/-/classcat-5.0.5.tgz", - "version": "5.0.5" + "integrity": "sha512-JhZUT7JFcQy/EzW605k/ktHtncoo9vnyW/2GspNYwFlN1C/WmjuV/xtS04e9SOkL2sTdw0VAZ2UGCcQ9lR6p6w==" }, "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", "engines": { "node": ">=6" - }, - "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", - "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", - "version": "2.1.1" + } }, "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, "dependencies": { "color-name": "~1.1.4" }, - "dev": true, "engines": { "node": ">=7.0.0" - }, - "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", - "version": "2.0.1" + } }, "node_modules/color-name": { - "dev": true, - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "version": "1.1.4", "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "version": "1.1.4" + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true }, "node_modules/commander": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", - "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", - "version": "4.1.1" + } }, "node_modules/concat-map": { - "dev": true, - "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "version": "0.0.1" + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true }, "node_modules/cookie": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz", + "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==", "dev": true, "engines": { "node": ">= 0.6" - }, - "integrity": "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.6.0.tgz", - "version": "0.6.0" + } }, "node_modules/core-js": { + "version": "3.47.0", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.47.0.tgz", + "integrity": "sha512-c3Q2VVkGAUyupsjRnaNX6u8Dq2vAdzm9iuPj5FW0fRxzlxgq9Q39MDq10IvmQSpLgHQNyQzQmOo6bgGHmH3NNg==", + "hasInstallScript": true, + "optional": true, "funding": { "type": "opencollective", "url": "https://opencollective.com/core-js" - }, - "hasInstallScript": true, - "integrity": "sha512-c3Q2VVkGAUyupsjRnaNX6u8Dq2vAdzm9iuPj5FW0fRxzlxgq9Q39MDq10IvmQSpLgHQNyQzQmOo6bgGHmH3NNg==", - "optional": true, - "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.47.0.tgz", - "version": "3.47.0" + } }, "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" }, - "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", - "version": "7.0.6" + } }, "node_modules/css-line-break": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/css-line-break/-/css-line-break-2.1.0.tgz", + "integrity": "sha512-FHcKFCZcAha3LwfVBhCQbW2nCNbkZXn7KVUJcsT5/P8YmfsVja0FMPJr0B903j/E69HUphKiV9iQArX8SDYA4w==", "dependencies": { "utrie": "^1.0.2" - }, - "integrity": "sha512-FHcKFCZcAha3LwfVBhCQbW2nCNbkZXn7KVUJcsT5/P8YmfsVja0FMPJr0B903j/E69HUphKiV9iQArX8SDYA4w==", - "resolved": "https://registry.npmjs.org/css-line-break/-/css-line-break-2.1.0.tgz", - "version": "2.1.0" + } }, "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "dev": true, "bin": { "cssesc": "bin/cssesc" }, - "dev": true, "engines": { "node": ">=4" - }, - "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", - "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", "dependencies": { "internmap": "1 - 2" }, "engines": { "node": ">=12" - }, - "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", - "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", - "version": "3.2.4" + } }, "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", "engines": { "node": ">=12" - }, - "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", - "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", - "version": "3.1.0" + } }, "node_modules/d3-dag": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/d3-dag/-/d3-dag-1.1.0.tgz", + "integrity": "sha512-N8IxsIHcUaIxLrV3cElTC47kVJGFiY3blqSuJubQhyhYBJs0syfFPTnRSj2Cq0LBxxi4mzJmcqCvHIv9sPdILQ==", "dependencies": { "d3-array": "^3.2.4", "javascript-lp-solver": "0.4.24", "quadprog": "^1.6.1", "stringify-object": "^5.0.0" - }, - "integrity": "sha512-N8IxsIHcUaIxLrV3cElTC47kVJGFiY3blqSuJubQhyhYBJs0syfFPTnRSj2Cq0LBxxi4mzJmcqCvHIv9sPdILQ==", - "resolved": "https://registry.npmjs.org/d3-dag/-/d3-dag-1.1.0.tgz", - "version": "1.1.0" + } }, "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", "engines": { "node": ">=12" - }, - "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", - "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", "dependencies": { "d3-dispatch": "1 - 3", "d3-selection": "3" }, "engines": { "node": ">=12" - }, - "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", - "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", "engines": { "node": ">=12" - }, - "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", - "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", "dependencies": { "d3-color": "1 - 3" }, "engines": { "node": ">=12" - }, - "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", - "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", "engines": { "node": ">=12" - }, - "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", - "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", "engines": { "node": ">=12" - }, - "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", - "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", "dependencies": { "d3-color": "1 - 3", "d3-dispatch": "1 - 3", @@ -1734,14 +1739,14 @@ "engines": { "node": ">=12" }, - "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", "peerDependencies": { "d3-selection": "2 - 3" - }, - "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", @@ -1751,85 +1756,84 @@ }, "engines": { "node": ">=12" - }, - "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", - "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, "dependencies": { "ms": "^2.1.3" }, - "dev": true, "engines": { "node": ">=6.0" }, - "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "peerDependenciesMeta": { "supports-color": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", - "version": "4.4.3" + } }, "node_modules/deep-is": { - "dev": true, - "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "version": "0.1.4", "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", - "version": "0.1.4" + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true }, "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", - "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", - "version": "4.3.1" + } }, "node_modules/devalue": { - "integrity": "sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==", + "version": "5.6.1", "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.1.tgz", - "version": "5.6.1" + "integrity": "sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==" }, "node_modules/didyoumean": { - "dev": true, - "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "version": "1.2.2", "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", - "version": "1.2.2" + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "dev": true }, "node_modules/dlv": { - "dev": true, - "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "version": "1.1.3", "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", - "version": "1.1.3" + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "dev": true }, "node_modules/dompurify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.1.tgz", "integrity": "sha512-qkdCKzLNtrgPFP1Vo+98FRzJnBRGe4ffyCea9IwHB1fyxPOeNTHpLKYGd4Uk9xvNoH0ZoOjwZxNptyMwqrId1Q==", "optional": true, "optionalDependencies": { "@types/trusted-types": "^2.0.7" - }, - "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.1.tgz", - "version": "3.3.1" + } }, "node_modules/electron-to-chromium": { - "dev": true, - "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==", + "version": "1.5.267", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz", - "version": "1.5.267" + "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==", + "dev": true }, "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, "bin": { "esbuild": "bin/esbuild" }, - "dev": true, "engines": { "node": ">=12" }, - "hasInstallScript": true, - "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", "optionalDependencies": { "@esbuild/aix-ppc64": "0.21.5", "@esbuild/android-arm": "0.21.5", @@ -1854,35 +1858,34 @@ "@esbuild/win32-arm64": "0.21.5", "@esbuild/win32-ia32": "0.21.5", "@esbuild/win32-x64": "0.21.5" - }, - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", - "version": "0.21.5" + } }, "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", - "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", - "version": "3.2.0" + } }, "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", - "version": "4.0.0" + } }, "node_modules/eslint": { - "bin": { - "eslint": "bin/eslint.js" - }, + "version": "9.39.2", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz", + "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==", + "dev": true, "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", @@ -1919,14 +1922,15 @@ "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, - "dev": true, + "bin": { + "eslint": "bin/eslint.js" + }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://eslint.org/donate" }, - "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==", "peerDependencies": { "jiti": "*" }, @@ -1934,125 +1938,127 @@ "jiti": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz", - "version": "9.39.2" + } }, "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://opencollective.com/eslint" - }, - "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", - "version": "8.4.0" + } }, "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://opencollective.com/eslint" - }, - "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", - "version": "4.2.1" + } }, "node_modules/esm-env": { - "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==", + "version": "1.2.2", "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz", - "version": "1.2.2" + "integrity": "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==" }, "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" }, - "dev": true, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, "funding": { "url": "https://opencollective.com/eslint" - }, - "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", - "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", - "version": "10.4.0" + } }, "node_modules/esquery": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "dev": true, "dependencies": { "estraverse": "^5.1.0" }, - "dev": true, "engines": { "node": ">=0.10" - }, - "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", - "version": "1.6.0" + } }, "node_modules/esrap": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.1.tgz", + "integrity": "sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==", "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15" - }, - "integrity": "sha512-GiYWG34AN/4CUyaWAgunGt0Rxvr1PTMlGC0vvEov/uOQYWne2bpN03Um+k8jT+q3op33mKouP2zeJ6OlM+qeUg==", - "resolved": "https://registry.npmjs.org/esrap/-/esrap-2.2.1.tgz", - "version": "2.2.1" + } }, "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "dev": true, "dependencies": { "estraverse": "^5.2.0" }, - "dev": true, "engines": { "node": ">=4.0" - }, - "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", - "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", - "version": "4.3.0" + } }, "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", "dev": true, "engines": { "node": ">=4.0" - }, - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "version": "5.3.0" + } }, "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", - "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", - "version": "2.0.3" + } }, "node_modules/fast-deep-equal": { - "dev": true, - "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "version": "3.1.3", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", - "version": "3.1.3" + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true }, "node_modules/fast-equals": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz", + "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==", "engines": { "node": ">=6.0.0" - }, - "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==", - "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz", - "version": "5.4.0" + } }, "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", @@ -2060,63 +2066,61 @@ "merge2": "^1.3.0", "micromatch": "^4.0.8" }, - "dev": true, "engines": { "node": ">=8.6.0" - }, - "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", - "version": "3.3.3" + } }, "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, "dependencies": { "is-glob": "^4.0.1" }, - "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "version": "5.1.2" + } }, "node_modules/fast-json-stable-stringify": { - "dev": true, - "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "version": "2.1.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", - "version": "2.1.0" + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true }, "node_modules/fast-levenshtein": { - "dev": true, - "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "version": "2.0.6", "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", - "version": "2.0.6" + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true }, "node_modules/fast-png": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/fast-png/-/fast-png-6.4.0.tgz", + "integrity": "sha512-kAqZq1TlgBjZcLr5mcN6NP5Rv4V2f22z00c3g8vRrwkcqjerx7BEhPbOnWCPqaHUl2XWQBJQvOT/FQhdMT7X/Q==", "dependencies": { "@types/pako": "^2.0.3", "iobuffer": "^5.3.2", "pako": "^2.1.0" - }, - "integrity": "sha512-kAqZq1TlgBjZcLr5mcN6NP5Rv4V2f22z00c3g8vRrwkcqjerx7BEhPbOnWCPqaHUl2XWQBJQvOT/FQhdMT7X/Q==", - "resolved": "https://registry.npmjs.org/fast-png/-/fast-png-6.4.0.tgz", - "version": "6.4.0" + } }, "node_modules/fastq": { + "version": "1.19.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "dev": true, "dependencies": { "reusify": "^1.0.4" - }, - "dev": true, - "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", - "version": "1.19.1" + } }, "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", "dev": true, "engines": { "node": ">=12.0.0" }, - "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", "peerDependencies": { "picomatch": "^3 || ^4" }, @@ -2124,75 +2128,76 @@ "picomatch": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", - "version": "6.5.0" + } }, "node_modules/fflate": { - "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==", + "version": "0.8.2", "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.2.tgz", - "version": "0.8.2" + "integrity": "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==" }, "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, "dependencies": { "flat-cache": "^4.0.0" }, - "dev": true, "engines": { "node": ">=16.0.0" - }, - "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", - "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", - "version": "8.0.0" + } }, "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, "dependencies": { "to-regex-range": "^5.0.1" }, - "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", - "version": "7.1.1" + } }, "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" }, - "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", - "version": "5.0.0" + } }, "node_modules/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" }, - "dev": true, "engines": { "node": ">=16" - }, - "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", - "version": "4.0.1" + } }, "node_modules/flatted": { - "dev": true, - "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "version": "3.3.3", "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", - "version": "3.3.3" + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "dev": true }, "node_modules/fraction.js": { + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz", + "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==", "dev": true, "engines": { "node": "*" @@ -2200,537 +2205,538 @@ "funding": { "type": "github", "url": "https://github.com/sponsors/rawify" - }, - "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==", - "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz", - "version": "5.3.4" + } }, "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", "dev": true, - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - }, "hasInstallScript": true, - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", "optional": true, "os": [ "darwin" ], - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "version": "2.3.3" + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } }, "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", "dev": true, "funding": { "url": "https://github.com/sponsors/ljharb" - }, - "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", - "version": "1.1.2" + } }, "node_modules/get-own-enumerable-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-own-enumerable-keys/-/get-own-enumerable-keys-1.0.0.tgz", + "integrity": "sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA==", "engines": { "node": ">=14.16" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA==", - "resolved": "https://registry.npmjs.org/get-own-enumerable-keys/-/get-own-enumerable-keys-1.0.0.tgz", - "version": "1.0.0" + } }, "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "dev": true, "dependencies": { "is-glob": "^4.0.3" }, - "dev": true, "engines": { "node": ">=10.13.0" - }, - "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", - "version": "6.0.2" + } }, "node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", "dev": true, "engines": { "node": ">=18" }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", - "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", - "version": "14.0.0" + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } }, "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", - "version": "4.0.0" + } }, "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dev": true, "dependencies": { "function-bind": "^1.1.2" }, - "dev": true, "engines": { "node": ">= 0.4" - }, - "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", - "version": "2.0.2" + } }, "node_modules/html2canvas": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/html2canvas/-/html2canvas-1.4.1.tgz", + "integrity": "sha512-fPU6BHNpsyIhr8yyMpTLLxAbkaK8ArIBcmZIRiBLiDhjeqvXolaEmDGmELFuX9I4xDcaKKcJl+TKZLqruBbmWA==", "dependencies": { "css-line-break": "^2.1.0", "text-segmentation": "^1.0.3" }, "engines": { "node": ">=8.0.0" - }, - "integrity": "sha512-fPU6BHNpsyIhr8yyMpTLLxAbkaK8ArIBcmZIRiBLiDhjeqvXolaEmDGmELFuX9I4xDcaKKcJl+TKZLqruBbmWA==", - "resolved": "https://registry.npmjs.org/html2canvas/-/html2canvas-1.4.1.tgz", - "version": "1.4.1" + } }, "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", "dev": true, "engines": { "node": ">= 4" - }, - "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", - "version": "5.3.2" + } }, "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "dev": true, "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" }, - "dev": true, "engines": { "node": ">=6" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", - "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", - "version": "3.3.1" + } }, "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "dev": true, "engines": { "node": ">=0.8.19" - }, - "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", - "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", - "version": "0.1.4" + } }, "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", "engines": { "node": ">=12" - }, - "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", - "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", - "version": "2.0.3" + } }, "node_modules/iobuffer": { - "integrity": "sha512-DRebOWuqDvxunfkNJAlc3IzWIPD5xVxwUNbHr7xKB8E6aLJxIPfNX3CoMJghcFjpv6RWQsrcJbghtEwSPoJqMA==", + "version": "5.4.0", "resolved": "https://registry.npmjs.org/iobuffer/-/iobuffer-5.4.0.tgz", - "version": "5.4.0" + "integrity": "sha512-DRebOWuqDvxunfkNJAlc3IzWIPD5xVxwUNbHr7xKB8E6aLJxIPfNX3CoMJghcFjpv6RWQsrcJbghtEwSPoJqMA==" }, "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, "dependencies": { "binary-extensions": "^2.0.0" }, - "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", - "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", - "version": "2.1.0" + } }, "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, "dependencies": { "hasown": "^2.0.2" }, - "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" - }, - "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", - "version": "2.16.1" + } }, "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", - "version": "2.1.1" + } }, "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, "dependencies": { "is-extglob": "^2.1.1" }, - "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", - "version": "4.0.3" + } }, "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", "dev": true, "engines": { "node": ">=0.12.0" - }, - "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", - "version": "7.0.0" + } }, "node_modules/is-obj": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-3.0.0.tgz", + "integrity": "sha512-IlsXEHOjtKhpN8r/tRFj2nDyTmHvcfNeu/nrRIcXE17ROeatXchkojffa1SpdqW4cr/Fj6QkEf/Gn4zf6KKvEQ==", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-IlsXEHOjtKhpN8r/tRFj2nDyTmHvcfNeu/nrRIcXE17ROeatXchkojffa1SpdqW4cr/Fj6QkEf/Gn4zf6KKvEQ==", - "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/is-reference": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz", + "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==", "dependencies": { "@types/estree": "^1.0.6" - }, - "integrity": "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw==", - "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-3.0.3.tgz", - "version": "3.0.3" + } }, "node_modules/is-regexp": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-3.1.0.tgz", + "integrity": "sha512-rbku49cWloU5bSMI+zaRaXdQHXnthP6DZ/vLnfdSKyL4zUzuWnomtOEiZZOd+ioQ+avFo/qau3KPTc7Fjy1uPA==", "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-rbku49cWloU5bSMI+zaRaXdQHXnthP6DZ/vLnfdSKyL4zUzuWnomtOEiZZOd+ioQ+avFo/qau3KPTc7Fjy1uPA==", - "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-3.1.0.tgz", - "version": "3.1.0" + } }, "node_modules/isexe": { - "dev": true, - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "version": "2.0.0" + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true }, "node_modules/javascript-lp-solver": { - "integrity": "sha512-5edoDKnMrt/u3M6GnZKDDIPxOyFOg+WrwDv8mjNiMC2DePhy2H9/FFQgf4ggywaXT1utvkxusJcjQUER72cZmA==", + "version": "0.4.24", "resolved": "https://registry.npmjs.org/javascript-lp-solver/-/javascript-lp-solver-0.4.24.tgz", - "version": "0.4.24" + "integrity": "sha512-5edoDKnMrt/u3M6GnZKDDIPxOyFOg+WrwDv8mjNiMC2DePhy2H9/FFQgf4ggywaXT1utvkxusJcjQUER72cZmA==" }, "node_modules/jiti": { + "version": "1.21.7", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "dev": true, "bin": { "jiti": "bin/jiti.js" - }, - "dev": true, - "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", - "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", - "version": "1.21.7" + } }, "node_modules/js-yaml": { - "bin": { - "js-yaml": "bin/js-yaml.js" - }, + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, "dependencies": { "argparse": "^2.0.1" }, - "dev": true, - "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", - "version": "4.1.1" + "bin": { + "js-yaml": "bin/js-yaml.js" + } }, "node_modules/json-buffer": { - "dev": true, - "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "version": "3.0.1", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", - "version": "3.0.1" + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "dev": true }, "node_modules/json-schema-traverse": { - "dev": true, - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "version": "0.4.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "version": "0.4.1" + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true }, "node_modules/json-stable-stringify-without-jsonify": { - "dev": true, - "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "version": "1.0.1", "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "version": "1.0.1" + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "dev": true }, "node_modules/jspdf": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/jspdf/-/jspdf-3.0.4.tgz", + "integrity": "sha512-dc6oQ8y37rRcHn316s4ngz/nOjayLF/FFxBF4V9zamQKRqXxyiH1zagkCdktdWhtoQId5K20xt1lB90XzkB+hQ==", "dependencies": { "@babel/runtime": "^7.28.4", "fast-png": "^6.2.0", "fflate": "^0.8.1" }, - "integrity": "sha512-dc6oQ8y37rRcHn316s4ngz/nOjayLF/FFxBF4V9zamQKRqXxyiH1zagkCdktdWhtoQId5K20xt1lB90XzkB+hQ==", "optionalDependencies": { "canvg": "^3.0.11", "core-js": "^3.6.0", "dompurify": "^3.2.4", "html2canvas": "^1.0.0-rc.5" - }, - "resolved": "https://registry.npmjs.org/jspdf/-/jspdf-3.0.4.tgz", - "version": "3.0.4" + } }, "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "dev": true, "dependencies": { "json-buffer": "3.0.1" - }, - "dev": true, - "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", - "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", - "version": "4.5.4" + } }, "node_modules/kleur": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", + "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==", "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==", - "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", - "version": "4.1.5" + } }, "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "dev": true, "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" }, - "dev": true, "engines": { "node": ">= 0.8.0" - }, - "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", - "version": "0.4.1" + } }, "node_modules/lilconfig": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", "dev": true, "engines": { "node": ">=14" }, "funding": { "url": "https://github.com/sponsors/antonk52" - }, - "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", - "version": "3.1.3" + } }, "node_modules/lines-and-columns": { - "dev": true, - "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "version": "1.2.4", "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", - "version": "1.2.4" + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true }, "node_modules/locate-character": { - "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==", + "version": "3.0.0", "resolved": "https://registry.npmjs.org/locate-character/-/locate-character-3.0.0.tgz", - "version": "3.0.0" + "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==" }, "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, "dependencies": { "p-locate": "^5.0.0" }, - "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", - "version": "6.0.0" + } }, "node_modules/lodash.merge": { - "dev": true, - "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "version": "4.6.2", "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", - "version": "4.6.2" + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true }, "node_modules/lucide-svelte": { + "version": "0.468.0", + "resolved": "https://registry.npmjs.org/lucide-svelte/-/lucide-svelte-0.468.0.tgz", "integrity": "sha512-n0ecAFtCY5LEeL+PJ1Xj4n3c2gzj8tMpak0KMGnvoSJEjCsCnRB0mekBtJZAo7beyynW9Qj5Um1KfMBAeTNplw==", "peerDependencies": { "svelte": "^3 || ^4 || ^5.0.0-next.42" - }, - "resolved": "https://registry.npmjs.org/lucide-svelte/-/lucide-svelte-0.468.0.tgz", - "version": "0.468.0" + } }, "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" - }, - "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", - "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", - "version": "0.30.21" + } }, "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", "dev": true, "engines": { "node": ">= 8" - }, - "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", - "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", - "version": "1.4.1" + } }, "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" }, - "dev": true, "engines": { "node": ">=8.6" - }, - "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", - "version": "4.0.8" + } }, "node_modules/micromatch/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", "dev": true, "engines": { "node": ">=8.6" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" - }, - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "version": "2.3.1" + } }, "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, "dependencies": { "brace-expansion": "^1.1.7" }, - "dev": true, "engines": { "node": "*" - }, - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "version": "3.1.2" + } }, "node_modules/monaco-editor": { - "integrity": "sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ==", + "version": "0.52.2", "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.52.2.tgz", - "version": "0.52.2" + "integrity": "sha512-GEQWEZmfkOGLdd3XK8ryrfWz3AIP8YymVXiPHEdewrUq7mh0qrKrfHLNCXcbB6sTnMLnOZ3ztSiKcciFUkIJwQ==" }, "node_modules/mri": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz", + "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==", "dev": true, "engines": { "node": ">=4" - }, - "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==", - "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz", - "version": "1.2.0" + } }, "node_modules/mrmime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz", + "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==", "dev": true, "engines": { "node": ">=10" - }, - "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==", - "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz", - "version": "2.0.1" + } }, "node_modules/ms": { - "dev": true, - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "version": "2.1.3", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "version": "2.1.3" + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true }, "node_modules/mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "dev": true, "dependencies": { "any-promise": "^1.0.0", "object-assign": "^4.0.1", "thenify-all": "^1.0.0" - }, - "dev": true, - "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", - "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", - "version": "2.7.0" + } }, "node_modules/nanoid": { - "bin": { - "nanoid": "bin/nanoid.cjs" - }, + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", "dev": true, - "engines": { - "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" - }, "funding": [ { "type": "github", "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", - "version": "3.3.11" + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } }, "node_modules/natural-compare": { - "dev": true, - "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "version": "1.4.0", "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", - "version": "1.4.0" + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "dev": true }, "node_modules/node-releases": { - "dev": true, - "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", + "version": "2.0.27", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz", - "version": "2.0.27" + "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", + "dev": true }, "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", - "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", - "version": "4.1.1" + } }, "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", - "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", @@ -2739,137 +2745,128 @@ "type-check": "^0.4.0", "word-wrap": "^1.2.5" }, - "dev": true, "engines": { "node": ">= 0.8.0" - }, - "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", - "version": "0.9.4" + } }, "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, "dependencies": { "yocto-queue": "^0.1.0" }, - "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "version": "3.1.0" + } }, "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, "dependencies": { "p-limit": "^3.0.2" }, - "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", - "version": "5.0.0" + } }, "node_modules/pako": { - "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==", + "version": "2.1.0", "resolved": "https://registry.npmjs.org/pako/-/pako-2.1.0.tgz", - "version": "2.1.0" + "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==" }, "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, "dependencies": { "callsites": "^3.0.0" }, - "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", - "version": "1.0.1" + } }, "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", - "version": "4.0.0" + } }, "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", - "version": "3.1.1" + } }, "node_modules/path-parse": { - "dev": true, - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "version": "1.0.7" + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true }, "node_modules/performance-now": { - "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", - "optional": true, + "version": "2.1.0", "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", - "version": "2.1.0" + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "optional": true }, "node_modules/picocolors": { - "dev": true, - "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "version": "1.1.1", "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", - "version": "1.1.1" + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true }, "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", "dev": true, "engines": { "node": ">=12" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" - }, - "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", - "version": "4.0.3" + } }, "node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "version": "2.3.0" + } }, "node_modules/pirates": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", + "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", - "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", - "version": "4.0.7" + } }, "node_modules/postcss": { - "dependencies": { - "nanoid": "^3.3.11", - "picocolors": "^1.1.1", - "source-map-js": "^1.2.1" - }, + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", "dev": true, - "engines": { - "node": "^10 || ^12 || >=14" - }, "funding": [ { "type": "opencollective", @@ -2884,35 +2881,37 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", - "version": "8.5.6" + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } }, "node_modules/postcss-import": { + "version": "15.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", + "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "dev": true, "dependencies": { "postcss-value-parser": "^4.0.0", "read-cache": "^1.0.0", "resolve": "^1.1.7" }, - "dev": true, "engines": { "node": ">=14.0.0" }, - "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", "peerDependencies": { "postcss": "^8.0.0" - }, - "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", - "version": "15.1.0" + } }, "node_modules/postcss-js": { - "dependencies": { - "camelcase-css": "^2.0.1" - }, + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz", + "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==", "dev": true, - "engines": { - "node": "^12 || ^14 || >= 16" - }, "funding": [ { "type": "opencollective", @@ -2923,21 +2922,21 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, "peerDependencies": { "postcss": "^8.4.21" - }, - "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz", - "version": "4.1.0" + } }, "node_modules/postcss-load-config": { - "dependencies": { - "lilconfig": "^3.1.1" - }, + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz", + "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==", "dev": true, - "engines": { - "node": ">= 18" - }, "funding": [ { "type": "opencollective", @@ -2948,7 +2947,12 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==", + "dependencies": { + "lilconfig": "^3.1.1" + }, + "engines": { + "node": ">= 18" + }, "peerDependencies": { "jiti": ">=1.21.0", "postcss": ">=8.0.9", @@ -2968,18 +2972,13 @@ "yaml": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz", - "version": "6.0.1" + } }, "node_modules/postcss-nested": { - "dependencies": { - "postcss-selector-parser": "^6.1.1" - }, + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", "dev": true, - "engines": { - "node": ">=12.0" - }, "funding": [ { "type": "opencollective", @@ -2990,59 +2989,65 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "dependencies": { + "postcss-selector-parser": "^6.1.1" + }, + "engines": { + "node": ">=12.0" + }, "peerDependencies": { "postcss": "^8.2.14" - }, - "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", - "version": "6.2.0" + } }, "node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" }, - "dev": true, "engines": { "node": ">=4" - }, - "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", - "version": "6.1.2" + } }, "node_modules/postcss-value-parser": { - "dev": true, - "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "version": "4.2.0", "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", - "version": "4.2.0" + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "dev": true }, "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", "dev": true, "engines": { "node": ">= 0.8.0" - }, - "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", - "version": "1.2.1" + } }, "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", - "version": "2.3.1" + } }, "node_modules/quadprog": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/quadprog/-/quadprog-1.6.1.tgz", + "integrity": "sha512-fN5Jkcjlln/b3pJkseDKREf89JkKIyu6cKIVXisgL6ocKPQ0yTp9n6NZUAq3otEPPw78WZMG9K0o9WsfKyMWJw==", "engines": { "node": ">=8.x" - }, - "integrity": "sha512-fN5Jkcjlln/b3pJkseDKREf89JkKIyu6cKIVXisgL6ocKPQ0yTp9n6NZUAq3otEPPw78WZMG9K0o9WsfKyMWJw==", - "resolved": "https://registry.npmjs.org/quadprog/-/quadprog-1.6.1.tgz", - "version": "1.6.1" + } }, "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", "dev": true, "funding": [ { @@ -3057,30 +3062,30 @@ "type": "consulting", "url": "https://feross.org/support" } - ], - "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", - "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", - "version": "1.2.3" + ] }, "node_modules/raf": { - "dependencies": { - "performance-now": "^2.1.0" - }, + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==", "optional": true, - "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", - "version": "3.4.1" + "dependencies": { + "performance-now": "^2.1.0" + } }, "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dev": true, "dependencies": { "pify": "^2.3.0" - }, - "dev": true, - "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", - "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", - "version": "1.0.0" + } }, "node_modules/readdirp": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", + "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", "dev": true, "engines": { "node": ">= 14.18.0" @@ -3088,78 +3093,77 @@ "funding": { "type": "individual", "url": "https://paulmillr.com/funding/" - }, - "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz", - "version": "4.1.2" + } }, "node_modules/regenerator-runtime": { - "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==", - "optional": true, + "version": "0.13.11", "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", - "version": "0.13.11" + "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==", + "optional": true }, "node_modules/resolve": { - "bin": { - "resolve": "bin/resolve" - }, + "version": "1.22.11", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", + "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", + "dev": true, "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, - "dev": true, + "bin": { + "resolve": "bin/resolve" + }, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" - }, - "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", - "version": "1.22.11" + } }, "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", "dev": true, "engines": { "node": ">=4" - }, - "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", - "version": "4.0.0" + } }, "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", "dev": true, "engines": { "iojs": ">=1.0.0", "node": ">=0.10.0" - }, - "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", - "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", - "version": "1.1.0" + } }, "node_modules/rgbcolor": { - "engines": { - "node": ">= 0.8.15" - }, + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/rgbcolor/-/rgbcolor-1.0.1.tgz", "integrity": "sha512-9aZLIrhRaD97sgVhtJOW6ckOEh6/GnvQtdVNfdZ6s67+3/XwLS9lBcQYzEEhYVeUowN7pRzMLsyGhK2i/xvWbw==", "optional": true, - "resolved": "https://registry.npmjs.org/rgbcolor/-/rgbcolor-1.0.1.tgz", - "version": "1.0.1" + "engines": { + "node": ">= 0.8.15" + } }, "node_modules/rollup": { - "bin": { - "rollup": "dist/bin/rollup" - }, + "version": "4.53.5", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.5.tgz", + "integrity": "sha512-iTNAbFSlRpcHeeWu73ywU/8KuU/LZmNCSxp6fjQkJBD3ivUb8tpDrXhIxEzA05HlYMEwmtaUnb3RP+YNv162OQ==", + "dev": true, "dependencies": { "@types/estree": "1.0.8" }, - "dev": true, + "bin": { + "rollup": "dist/bin/rollup" + }, "engines": { "node": ">=18.0.0", "npm": ">=8.0.0" }, - "integrity": "sha512-iTNAbFSlRpcHeeWu73ywU/8KuU/LZmNCSxp6fjQkJBD3ivUb8tpDrXhIxEzA05HlYMEwmtaUnb3RP+YNv162OQ==", "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.53.5", "@rollup/rollup-android-arm64": "4.53.5", @@ -3184,14 +3188,12 @@ "@rollup/rollup-win32-x64-gnu": "4.53.5", "@rollup/rollup-win32-x64-msvc": "4.53.5", "fsevents": "~2.3.2" - }, - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.5.tgz", - "version": "4.53.5" + } }, "node_modules/run-parallel": { - "dependencies": { - "queue-microtask": "^1.2.2" - }, + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", "dev": true, "funding": [ { @@ -3207,87 +3209,90 @@ "url": "https://feross.org/support" } ], - "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", - "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", - "version": "1.2.0" + "dependencies": { + "queue-microtask": "^1.2.2" + } }, "node_modules/sade": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz", + "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==", + "dev": true, "dependencies": { "mri": "^1.1.0" }, - "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==", - "resolved": "https://registry.npmjs.org/sade/-/sade-1.8.1.tgz", - "version": "1.8.1" + } }, "node_modules/set-cookie-parser": { - "dev": true, - "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==", + "version": "2.7.2", "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz", - "version": "2.7.2" + "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==", + "dev": true }, "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, "dependencies": { "shebang-regex": "^3.0.0" }, - "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", - "version": "2.0.0" + } }, "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", - "version": "3.0.0" + } }, "node_modules/sirv": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz", + "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==", + "dev": true, "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", "totalist": "^3.0.0" }, - "dev": true, "engines": { "node": ">=18" - }, - "integrity": "sha512-2wcC/oGxHis/BoHkkPwldgiPSYcpZK3JU28WoMVv55yHJgcZ8rlXvuG9iZggz+sU1d4bRgIGASwyWqjxu3FM0g==", - "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz", - "version": "3.0.2" + } }, "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", - "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", - "version": "1.2.1" + } }, "node_modules/stackblur-canvas": { - "engines": { - "node": ">=0.1.14" - }, + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/stackblur-canvas/-/stackblur-canvas-2.7.0.tgz", "integrity": "sha512-yf7OENo23AGJhBriGx0QivY5JP6Y1HbrrDI6WLt6C5auYZXlQrheoY8hD4ibekFKz1HOfE48Ww8kMWMnJD/zcQ==", "optional": true, - "resolved": "https://registry.npmjs.org/stackblur-canvas/-/stackblur-canvas-2.7.0.tgz", - "version": "2.7.0" + "engines": { + "node": ">=0.1.14" + } }, "node_modules/state-local": { - "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==", + "version": "1.0.7", "resolved": "https://registry.npmjs.org/state-local/-/state-local-1.0.7.tgz", - "version": "1.0.7" + "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==" }, "node_modules/stringify-object": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-5.0.0.tgz", + "integrity": "sha512-zaJYxz2FtcMb4f+g60KsRNFOpVMUyuJgA51Zi5Z1DOTC3S59+OQiVOzE9GZt0x72uBGWKsQIuBKeF9iusmKFsg==", "dependencies": { "get-own-enumerable-keys": "^1.0.0", "is-obj": "^3.0.0", @@ -3298,28 +3303,25 @@ }, "funding": { "url": "https://github.com/yeoman/stringify-object?sponsor=1" - }, - "integrity": "sha512-zaJYxz2FtcMb4f+g60KsRNFOpVMUyuJgA51Zi5Z1DOTC3S59+OQiVOzE9GZt0x72uBGWKsQIuBKeF9iusmKFsg==", - "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-5.0.0.tgz", - "version": "5.0.0" + } }, "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, "engines": { "node": ">=8" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", - "version": "3.1.1" + } }, "node_modules/sucrase": { - "bin": { - "sucrase": "bin/sucrase", - "sucrase-node": "bin/sucrase-node" - }, + "version": "3.35.1", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz", + "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==", + "dev": true, "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", @@ -3329,39 +3331,42 @@ "tinyglobby": "^0.2.11", "ts-interface-checker": "^0.1.9" }, - "dev": true, + "bin": { + "sucrase": "bin/sucrase", + "sucrase-node": "bin/sucrase-node" + }, "engines": { "node": ">=16 || 14 >=14.17" - }, - "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==", - "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz", - "version": "3.35.1" + } }, "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, "dependencies": { "has-flag": "^4.0.0" }, - "dev": true, "engines": { "node": ">=8" - }, - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "version": "7.2.0" + } }, "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", "dev": true, "engines": { "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" - }, - "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", - "version": "1.0.0" + } }, "node_modules/svelte": { + "version": "5.46.0", + "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.46.0.tgz", + "integrity": "sha512-ZhLtvroYxUxr+HQJfMZEDRsGsmU46x12RvAv/zi9584f5KOX7bUrEbhPJ7cKFmUvZTJXi/CFZUYwDC6M1FigPw==", "dependencies": { "@jridgewell/remapping": "^2.3.4", "@jridgewell/sourcemap-codec": "^1.5.0", @@ -3381,15 +3386,13 @@ }, "engines": { "node": ">=18" - }, - "integrity": "sha512-ZhLtvroYxUxr+HQJfMZEDRsGsmU46x12RvAv/zi9584f5KOX7bUrEbhPJ7cKFmUvZTJXi/CFZUYwDC6M1FigPw==", - "resolved": "https://registry.npmjs.org/svelte/-/svelte-5.46.0.tgz", - "version": "5.46.0" + } }, "node_modules/svelte-check": { - "bin": { - "svelte-check": "bin/svelte-check" - }, + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.3.4.tgz", + "integrity": "sha512-DVWvxhBrDsd+0hHWKfjP99lsSXASeOhHJYyuKOFYJcP7ThfSCKgjVarE8XfuMWpS5JV3AlDf+iK1YGGo2TACdw==", + "dev": true, "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "chokidar": "^4.0.1", @@ -3397,32 +3400,31 @@ "picocolors": "^1.0.0", "sade": "^1.7.4" }, - "dev": true, + "bin": { + "svelte-check": "bin/svelte-check" + }, "engines": { "node": ">= 18.0.0" }, - "integrity": "sha512-DVWvxhBrDsd+0hHWKfjP99lsSXASeOhHJYyuKOFYJcP7ThfSCKgjVarE8XfuMWpS5JV3AlDf+iK1YGGo2TACdw==", "peerDependencies": { "svelte": "^4.0.0 || ^5.0.0-next.0", "typescript": ">=5.0.0" - }, - "resolved": "https://registry.npmjs.org/svelte-check/-/svelte-check-4.3.4.tgz", - "version": "4.3.4" + } }, "node_modules/svg-pathdata": { - "engines": { - "node": ">=12.0.0" - }, + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/svg-pathdata/-/svg-pathdata-6.0.3.tgz", "integrity": "sha512-qsjeeq5YjBZ5eMdFuUa4ZosMLxgr5RZ+F+Y1OrDhuOCEInRMA3x74XdBtggJcj9kOeInz0WE+LgCPDkZFlBYJw==", "optional": true, - "resolved": "https://registry.npmjs.org/svg-pathdata/-/svg-pathdata-6.0.3.tgz", - "version": "6.0.3" + "engines": { + "node": ">=12.0.0" + } }, "node_modules/tailwindcss": { - "bin": { - "tailwind": "lib/cli.js", - "tailwindcss": "lib/cli.js" - }, + "version": "3.4.19", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz", + "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==", + "dev": true, "dependencies": { "@alloc/quick-lru": "^5.2.0", "arg": "^5.0.2", @@ -3447,15 +3449,19 @@ "resolve": "^1.22.8", "sucrase": "^3.35.0" }, - "dev": true, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, "engines": { "node": ">=14.0.0" - }, - "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==", - "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz", - "version": "3.4.19" + } }, "node_modules/tailwindcss/node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, "dependencies": { "anymatch": "~3.1.2", "braces": "~3.0.2", @@ -3465,167 +3471,159 @@ "normalize-path": "~3.0.0", "readdirp": "~3.6.0" }, - "dev": true, "engines": { "node": ">= 8.10.0" }, "funding": { "url": "https://paulmillr.com/funding/" }, - "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", "optionalDependencies": { "fsevents": "~2.3.2" - }, - "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", - "version": "3.6.0" + } }, "node_modules/tailwindcss/node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, "dependencies": { "is-glob": "^4.0.1" }, - "dev": true, "engines": { "node": ">= 6" - }, - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "version": "5.1.2" + } }, "node_modules/tailwindcss/node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", "dev": true, "engines": { "node": ">=8.6" }, "funding": { "url": "https://github.com/sponsors/jonschlinkert" - }, - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "version": "2.3.1" + } }, "node_modules/tailwindcss/node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, "dependencies": { "picomatch": "^2.2.1" }, - "dev": true, "engines": { "node": ">=8.10.0" - }, - "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", - "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", - "version": "3.6.0" + } }, "node_modules/text-segmentation": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/text-segmentation/-/text-segmentation-1.0.3.tgz", + "integrity": "sha512-iOiPUo/BGnZ6+54OsWxZidGCsdU8YbE4PSpdPinp7DeMtUJNJBoJ/ouUSTJjHkh1KntHaltHl/gDs2FC4i5+Nw==", "dependencies": { "utrie": "^1.0.2" - }, - "integrity": "sha512-iOiPUo/BGnZ6+54OsWxZidGCsdU8YbE4PSpdPinp7DeMtUJNJBoJ/ouUSTJjHkh1KntHaltHl/gDs2FC4i5+Nw==", - "resolved": "https://registry.npmjs.org/text-segmentation/-/text-segmentation-1.0.3.tgz", - "version": "1.0.3" + } }, "node_modules/thenify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "dev": true, "dependencies": { "any-promise": "^1.0.0" - }, - "dev": true, - "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", - "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", - "version": "3.3.1" + } }, "node_modules/thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "dev": true, "dependencies": { "thenify": ">= 3.1.0 < 4" }, - "dev": true, "engines": { "node": ">=0.8" - }, - "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", - "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", - "version": "1.6.0" + } }, "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" }, - "dev": true, "engines": { "node": ">=12.0.0" }, "funding": { "url": "https://github.com/sponsors/SuperchupuDev" - }, - "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", - "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", - "version": "0.2.15" + } }, "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, "dependencies": { "is-number": "^7.0.0" }, - "dev": true, "engines": { "node": ">=8.0" - }, - "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", - "version": "5.0.1" + } }, "node_modules/totalist": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", + "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==", "dev": true, "engines": { "node": ">=6" - }, - "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==", - "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", - "version": "3.0.1" + } }, "node_modules/ts-interface-checker": { - "dev": true, - "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "version": "0.1.13", "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", - "version": "0.1.13" + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "dev": true }, "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "dev": true, "dependencies": { "prelude-ls": "^1.2.1" }, - "dev": true, "engines": { "node": ">= 0.8.0" - }, - "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", - "version": "0.4.0" + } }, "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" }, - "dev": true, "engines": { "node": ">=14.17" - }, - "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", - "version": "5.9.3" + } }, "node_modules/undici-types": { - "dev": true, - "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "version": "6.21.0", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", - "version": "6.21.0" + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true }, "node_modules/update-browserslist-db": { - "bin": { - "update-browserslist-db": "cli.js" - }, - "dependencies": { - "escalade": "^3.2.0", - "picocolors": "^1.1.1" - }, + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", "dev": true, "funding": [ { @@ -3641,53 +3639,59 @@ "url": "https://github.com/sponsors/ai" } ], - "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, "peerDependencies": { "browserslist": ">= 4.21.0" - }, - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", - "version": "1.2.3" + } }, "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, "dependencies": { "punycode": "^2.1.0" - }, - "dev": true, - "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", - "version": "4.4.1" + } }, "node_modules/util-deprecate": { - "dev": true, - "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "version": "1.0.2" + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true }, "node_modules/utrie": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/utrie/-/utrie-1.0.2.tgz", + "integrity": "sha512-1MLa5ouZiOmQzUbjbu9VmjLzn1QLXBhwpUa7kdLUQK+KQ5KA9I1vk5U4YHe/X2Ch7PYnJfWuWT+VbuxbGwljhw==", "dependencies": { "base64-arraybuffer": "^1.0.2" - }, - "integrity": "sha512-1MLa5ouZiOmQzUbjbu9VmjLzn1QLXBhwpUa7kdLUQK+KQ5KA9I1vk5U4YHe/X2Ch7PYnJfWuWT+VbuxbGwljhw==", - "resolved": "https://registry.npmjs.org/utrie/-/utrie-1.0.2.tgz", - "version": "1.0.2" + } }, "node_modules/vite": { - "bin": { - "vite": "bin/vite.js" - }, + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, "dependencies": { "esbuild": "^0.21.3", "postcss": "^8.4.43", "rollup": "^4.20.0" }, - "dev": true, + "bin": { + "vite": "bin/vite.js" + }, "engines": { "node": "^18.0.0 || >=20.0.0" }, "funding": { "url": "https://github.com/vitejs/vite?sponsor=1" }, - "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", "optionalDependencies": { "fsevents": "~2.3.3" }, @@ -3726,13 +3730,13 @@ "terser": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", - "version": "5.4.21" + } }, "node_modules/vitefu": { - "dev": true, + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.1.tgz", "integrity": "sha512-B/Fegf3i8zh0yFbpzZ21amWzHmuNlLlmJT6n7bu5e+pCHUKQIfXSYokrqOBGEMMe9UG2sostKQF9mml/vYaWJQ==", + "dev": true, "peerDependencies": { "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0" }, @@ -3740,52 +3744,48 @@ "vite": { "optional": true } - }, - "resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.1.tgz", - "version": "1.1.1" + } }, "node_modules/which": { - "bin": { - "node-which": "bin/node-which" - }, + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, "dependencies": { "isexe": "^2.0.0" }, - "dev": true, + "bin": { + "node-which": "bin/node-which" + }, "engines": { "node": ">= 8" - }, - "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", - "version": "2.0.2" + } }, "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", "dev": true, "engines": { "node": ">=0.10.0" - }, - "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", - "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", - "version": "1.2.5" + } }, "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, "engines": { "node": ">=10" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" - }, - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "version": "0.1.0" + } }, "node_modules/zimmerframe": { - "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==", + "version": "1.1.4", "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz", - "version": "1.1.4" + "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==" } - }, - "requires": true, - "version": "0.1.0" + } } diff --git a/sygra/core/dataset/dataset_processor.py b/sygra/core/dataset/dataset_processor.py index d6e84cfb..85beb45e 100644 --- a/sygra/core/dataset/dataset_processor.py +++ b/sygra/core/dataset/dataset_processor.py @@ -439,6 +439,7 @@ async def _process_and_store_results(self): output_data = [] with open(output_file, "r") as f: output_data = json.load(f) + processed_output_data = output_data for post_processor in post_processors: processor_path = None processor_params: dict[str, Any] = {} @@ -458,9 +459,15 @@ async def _process_and_store_results(self): metadata = {"output_file": output_file, "params": processor_params} processor_cls = utils.get_func_from_str(processor_path) processor_name = processor_path.split(".")[-1] - processed_output_data = processor_cls(**processor_params).process( - output_data, metadata - ) + use_previous_output = processor_params.get("use_previous_output", False) + if use_previous_output: + processed_output_data = processor_cls(**processor_params).process( + processed_output_data, metadata + ) + else: + processed_output_data = processor_cls(**processor_params).process( + output_data, metadata + ) new_output_file = output_file[: output_file.rfind("/") + 1] + output_file[ output_file.rfind("/") + 1 : ].replace("output", processor_name, 1) diff --git a/sygra/core/eval/metrics/aggregator_metrics/pass_at_k.py b/sygra/core/eval/metrics/aggregator_metrics/pass_at_k.py index a2877832..08cf0dba 100644 --- a/sygra/core/eval/metrics/aggregator_metrics/pass_at_k.py +++ b/sygra/core/eval/metrics/aggregator_metrics/pass_at_k.py @@ -63,28 +63,33 @@ def get_metadata(self) -> BaseMetricMetadata: ) def calculate(self, results: List[UnitMetricResult]) -> Dict[str, Any]: - """Calculate Pass@k score. + """Calculate Pass@k scores for all k values from 1 to configured k. Args: results: List of UnitMetricResult Returns: - dict: {"pass@k": float (0.0 to 1.0)} + dict: {"pass@1": float, "pass@2": float, ..., "pass@k": float} """ if not results: logger.warning(f"{self.__class__.__name__}: No results provided") - return { - "pass@k": 0.0, - } + return {f"pass@{i}": 0.0 for i in range(1, self.k + 1)} + # Total number of attempts/samples n = len(results) # Number of correct solutions c = self._count_correct(results) - pass_at_k_value = self.pass_at_k(n, c, self.k) - return { - "pass@k": pass_at_k_value, - } + # Calculate pass@k for all values from 1 to k + result_dict = {} + for k_val in range(1, self.k + 1): + if k_val <= n: + result_dict[f"pass@{k_val}"] = self.pass_at_k(n, c, k_val) + else: + # If k_val > n, we can't calculate it + result_dict[f"pass@{k_val}"] = 0.0 + + return result_dict @staticmethod def pass_at_k(n: int, c: int, k: int) -> float: diff --git a/sygra/core/eval/metrics/aggregator_metrics/pass_power_k.py b/sygra/core/eval/metrics/aggregator_metrics/pass_power_k.py index 61efd068..4d044937 100644 --- a/sygra/core/eval/metrics/aggregator_metrics/pass_power_k.py +++ b/sygra/core/eval/metrics/aggregator_metrics/pass_power_k.py @@ -46,21 +46,23 @@ def get_metadata(self) -> BaseMetricMetadata: ) def calculate(self, results: List[UnitMetricResult]) -> Dict[str, Any]: - """Calculate Pass^k score. + """Calculate Pass^k scores for all k values from 1 to configured k. Args: results: List of UnitMetricResult Returns: - dict: Dictionary containing metrics and related information - {"success_rate": float (0.0 to 1.0), "pass^k": float (0.0 to 1.0)} + dict: {"success_rate": float, "pass^1": float, "pass^2": float, ..., "pass^k": float} Raises: ValueError: If invalid parameters are provided """ if not results: logger.warning(f"{self.__class__.__name__}: No results provided") - return {"success_rate": 0.0, "pass^k": 0.0} + result_dict = {"success_rate": 0.0} + result_dict.update({f"pass^{i}": 0.0 for i in range(1, self.k + 1)}) + return result_dict + # Total number of attempts/samples n = len(results) # Number of correct solutions @@ -74,9 +76,13 @@ def calculate(self, results: List[UnitMetricResult]) -> Dict[str, Any]: raise ValueError("Correct solutions (c) cannot exceed total attempts (n)") success_rate = self._safe_divide(c, n) - pass_power_k_value = self.pass_power_k(success_rate, self.k) - return {"success_rate": success_rate, "pass^k": pass_power_k_value} + # Calculate pass^k for all values from 1 to k + result_dict = {"success_rate": success_rate} + for k_val in range(1, self.k + 1): + result_dict[f"pass^{k_val}"] = self.pass_power_k(success_rate, k_val) + + return result_dict @staticmethod def pass_power_k(success_rate: float, k: int) -> float: diff --git a/sygra/core/eval/metrics/aggregator_metrics/step_efficiency.py b/sygra/core/eval/metrics/aggregator_metrics/step_efficiency.py new file mode 100644 index 00000000..e40ee8b6 --- /dev/null +++ b/sygra/core/eval/metrics/aggregator_metrics/step_efficiency.py @@ -0,0 +1,215 @@ +""" +Step Efficiency Metric + +Calculates step efficiency based on which retry number is correct. +- First retry correct: no penalty (efficiency = 1.0) +- No correct answer: add penalty (efficiency = 0.0) +- Later retries correct: efficiency decreases based on retry number +""" + +from typing import Any, Dict, List + +from pydantic import BaseModel, Field, field_validator + +from sygra.core.eval.metrics.aggregator_metrics.aggregator_metric_registry import aggregator_metric +from sygra.core.eval.metrics.aggregator_metrics.base_aggregator_metric import BaseAggregatorMetric +from sygra.core.eval.metrics.base_metric_metadata import BaseMetricMetadata +from sygra.core.eval.metrics.unit_metrics.unit_metric_result import UnitMetricResult +from sygra.logger.logger_config import logger + + +class StepEfficiencyMetricConfig(BaseModel): + """Configuration for Step Efficiency Metric""" + + penalty_per_retry: float = Field( + default=0.2, + description="Penalty to apply per retry attempt (default: 0.2, meaning 20% reduction per retry)", + ) + + @field_validator("penalty_per_retry") + @classmethod + def validate_penalty(cls, v): + if v is None or v < 0 or v > 1: + raise ValueError( + "penalty_per_retry must be between 0 and 1 (e.g., 0.2 for 20% penalty per retry)" + ) + return v + + +@aggregator_metric("step_efficiency") +class StepEfficiencyMetric(BaseAggregatorMetric): + """Calculate step efficiency based on retry number when correct answer is found. + + Efficiency calculation: + - First attempt correct (retry_number = 0): efficiency = 1.0 (no penalty) + - Second attempt correct (retry_number = 1): efficiency = 1.0 - penalty_per_retry + - Third attempt correct (retry_number = 2): efficiency = 1.0 - 2 * penalty_per_retry + - No correct answer: efficiency = 0.0 + + Required metadata in UnitMetricResult: + - retry_number: int (0-indexed, where 0 is first attempt) + + Optional configuration: + penalty_per_retry: float (default: 0.2) - penalty applied per retry + """ + + def __init__(self, **config): + """Initialize step efficiency metric with two-phase initialization.""" + super().__init__(**config) + self.validate_config() + self.metadata = self.get_metadata() + + def validate_config(self): + """Validate and store step efficiency configuration requirements""" + # Validate using Pydantic config class + config_obj = StepEfficiencyMetricConfig(**self.config) + + # Store validated fields as instance attributes + self.penalty_per_retry = config_obj.penalty_per_retry + + def get_metadata(self) -> BaseMetricMetadata: + """Return metadata for step efficiency metric""" + return BaseMetricMetadata( + name="step_efficiency", + display_name="Step Efficiency", + description="Efficiency score based on which retry attempt produces correct answer. " + "First attempt = 1.0, later attempts have penalties, no correct = 0.0", + range=(0.0, 1.0), + higher_is_better=True, + metric_type="custom", + ) + + def calculate(self, results: List[UnitMetricResult]) -> Dict[str, Any]: + """Calculate step efficiency from unit metric results. + + Args: + results: List of UnitMetricResult from validators + Each result should have metadata['retry_number'] indicating attempt number + + Returns: + dict: { + "step_efficiency": float (0.0 to 1.0), + "total_steps": int, + "first_attempt_correct": int, + "retry_correct": int, + "never_correct": int, + "avg_retries_when_correct": float + } + """ + if not results: + logger.warning(f"{self.__class__.__name__}: No results provided") + return self._empty_result() + + # Group results by step (mission_id + step_id) + steps = self._group_by_step(results) + + total_steps = len(steps) + first_attempt_correct = 0 + retry_correct = 0 + never_correct = 0 + total_efficiency = 0.0 + total_retries_when_correct = 0 + steps_with_correct = 0 + + for step_id, step_results in steps.items(): + # Sort by retry number to process in order + sorted_results = sorted(step_results, key=lambda r: self._get_retry_number(r)) + + # Find first correct result + first_correct_idx = None + first_correct_retry_num = None + + for idx, result in enumerate(sorted_results): + if result.correct: + first_correct_idx = idx + first_correct_retry_num = self._get_retry_number(result) + break + + if first_correct_idx is not None and first_correct_retry_num is not None: + # Calculate efficiency for this step + retry_num = first_correct_retry_num + step_efficiency = max(0.0, 1.0 - (retry_num * self.penalty_per_retry)) + total_efficiency += step_efficiency + + # Track statistics + if retry_num == 0: + first_attempt_correct += 1 + else: + retry_correct += 1 + + total_retries_when_correct += retry_num + steps_with_correct += 1 + else: + # No correct answer found for this step + never_correct += 1 + # Efficiency is 0.0 for this step (already added as 0) + + # Calculate overall metrics + overall_efficiency = self._safe_divide(total_efficiency, total_steps) + avg_retries_when_correct = ( + self._safe_divide(total_retries_when_correct, steps_with_correct) + if steps_with_correct > 0 + else 0.0 + ) + + return { + "step_efficiency": overall_efficiency, + "total_steps": total_steps, + "first_attempt_correct": first_attempt_correct, + "retry_correct": retry_correct, + "never_correct": never_correct, + "avg_retries_when_correct": avg_retries_when_correct, + } + + def _get_retry_number(self, result: UnitMetricResult) -> int: + """Extract retry number from metadata. + + Supports two formats: + 1. retry_number: int (direct value) + 2. retry_id: str (e.g., "retry_0" -> 0) + + Args: + result: UnitMetricResult with metadata + + Returns: + int: Retry number (0-indexed) + """ + # Check if retry_number is directly available + if "retry_number" in result.metadata: + retry_num = result.metadata.get("retry_number", 0) + return retry_num if retry_num is not None else 0 + + # Extract from retry_id if available + retry_id = result.metadata.get("retry_id", "retry_0") + if isinstance(retry_id, str) and "_" in retry_id: + try: + return int(retry_id.split("_")[-1]) + except (ValueError, IndexError): + return 0 + + return 0 + + def _group_by_step(self, results: List[UnitMetricResult]) -> Dict[str, List[UnitMetricResult]]: + """Group results by step identifier (mission_id + step_id)""" + steps: Dict[str, List[UnitMetricResult]] = {} + for result in results: + mission_id = result.metadata.get("mission_id", "unknown") + step_id = result.metadata.get("step_id", "unknown") + step_key = f"{mission_id}_{step_id}" + + if step_key not in steps: + steps[step_key] = [] + steps[step_key].append(result) + + return steps + + def _empty_result(self) -> Dict[str, Any]: + """Return empty result structure when no results provided""" + return { + "step_efficiency": 0.0, + "total_steps": 0, + "first_attempt_correct": 0, + "retry_correct": 0, + "never_correct": 0, + "avg_retries_when_correct": 0.0, + } diff --git a/sygra/processors/data_transform.py b/sygra/processors/data_transform.py index 1e72f4e0..f825dfe1 100644 --- a/sygra/processors/data_transform.py +++ b/sygra/processors/data_transform.py @@ -474,3 +474,70 @@ def _guess_mime(self, item: Any) -> str: return "audio/wav" return "audio/wav" # Default fallback + + +class AddRetryFieldsTransform(DataTransform): + """Transformer for adding retry-related fields to dictionary records. + + This transformer adds curr_retries and max_retries fields to each record + to support the retry logic in web agent evaluation. + """ + + @property + def name(self) -> str: + """Get the name of the add retry fields transformation. + + Returns: + str: The identifier 'add_retry_fields'. + """ + return "add_retry_fields" + + def transform(self, data: list[dict[str, Any]], params: dict[str, Any]) -> list[dict[str, Any]]: + """Add retry fields to each record. + + Args: + data (list[dict[str, Any]]): List of dictionary records to transform. + params (dict[str, Any]): Parameters containing: + - max_retries (int): Maximum number of retries (default: 3) + - initial_retry_count (int): Initial retry count (default: 0) + + Returns: + list[dict[str, Any]]: Transformed records with retry fields added. + """ + max_retries = params.get("max_retries", 3) + initial_retry_count = params.get("initial_retry_count", 0) + original_current_user_text = params.get("original_current_user_text", "") + logger.info( + f"AddRetryFieldsTransform: Adding max_retries={max_retries}, curr_retries={initial_retry_count} to {len(data)} records" + ) + + return [ + self._add_retry_fields( + record, max_retries, initial_retry_count, original_current_user_text + ) + for record in data + ] + + def _add_retry_fields( + self, + record: dict[str, Any], + max_retries: int, + initial_retry_count: int, + original_current_user_text: str, + ) -> dict[str, Any]: + """Add retry fields to a single record. + + Args: + record (dict[str, Any]): Dictionary record to transform. + max_retries (int): Maximum number of retries. + initial_retry_count (int): Initial retry count. + original_current_user_text (str): Original current user text. + + Returns: + dict[str, Any]: Transformed record with retry fields added. + """ + new_record = record.copy() + new_record["max_retries"] = max_retries + new_record["curr_retries"] = initial_retry_count + new_record["original_current_user_text"] = original_current_user_text + return new_record diff --git a/tasks/eval/README.md b/tasks/eval/README.md deleted file mode 100644 index 6aec30a4..00000000 --- a/tasks/eval/README.md +++ /dev/null @@ -1,308 +0,0 @@ -# Evaluation Tasks (`tasks/eval`) - -SyGra is a graph-oriented workflow framework for synthetic data generation **and evaluation**. Evaluation tasks are implemented as standard SyGra tasks (a `graph_config.yaml` + optional Python utilities) and produce: - -- **Per-record outputs** (including unit metric results) -- **Aggregated evaluation reports** (aggregator metrics computed after the run) - -## Quick start - -Run an eval task through `main.py`: - -```bash -uv run python main.py --task tasks.eval.question_answering.simpleqa --num_records 50 -``` - -You can also omit the `tasks.` prefix: - -```bash -uv run python main.py --task eval/classification/simpleqa --num_records 50 -``` - -To control where artifacts are written: - -```bash -uv run python main.py \ - --task tasks.eval.question_answering.simpleqa \ - --num_records 50 \ - --output_dir /abs/path/to/my_eval_outputs -``` - -## Concepts - -SyGra evaluation is organized into two metric layers: - -- **Unit metrics** - - Per-record metrics computed *inside the graph*. - - Stored back into the record/state (e.g., `exact_match_result`). -- **Aggregator metrics** - - Dataset-level metrics computed *after the run* by aggregating unit metric outputs (e.g., accuracy, precision, recall, F1). - - Produced by graph-level post-processing. - -### Key files and registries - -- **Generic eval utilities**: `tasks/eval/utils.py` - - `UnitMetrics`: reusable `lambda` node implementation that computes unit metrics via `UnitMetricRegistry`. - - `MetricCollatorPostProcessor`: reusable graph post-processor that computes aggregator metrics via `AggregatorMetricRegistry`. -- **Unit metric registry**: `sygra.core.eval.metrics.unit_metrics.unit_metric_registry.UnitMetricRegistry` -- **Aggregator metric registry**: `sygra.core.eval.metrics.aggregator_metrics.aggregator_metric_registry.AggregatorMetricRegistry` - -## Evaluation lifecycle - -At a high level, an eval task runs as follows: - -1. **Load task config** - - Task configs live under `tasks//graph_config.yaml`. - -2. **Load dataset** - - Configured in `data_config.source`. - - Common sources: HuggingFace (`type: hf`) or local disk. - -3. **Execute the graph per record** - - Nodes (LLM / lambda / sampler / etc.) run and update the `SygraState`. - -4. **Compute unit metrics per record (inside the graph)** - - Typically implemented as a `lambda` node. - - Example used in eval tasks: `tasks.eval.utils.UnitMetrics` - - Unit metric outputs are stored back into the record (e.g., `exact_match_result`). - -5. **Write the per-record output file** - - The framework writes a file named like `output_*.json` or `output_*.jsonl`. - -6. **Compute aggregator metrics (graph post-processing)** - - Configured via `graph_post_process` in the task YAML. - - Framework reads the output file back and runs each configured graph post processor. - - For eval tasks this is commonly: `tasks.eval.utils.MetricCollatorPostProcessor`. - -7. **Write aggregator results file(s)** - - For each post processor, SyGra writes a new file by replacing the `output` prefix in the filename with the post-processor class name. - - Example: `output_2026-01-27_12-31-46.json` -> `MetricCollatorPostProcessor_2026-01-27_12-31-46.json` - -## Using `tasks/eval/utils.py` in eval graphs - -### Unit metrics (generic `UnitMetrics` lambda) - -`tasks.eval.utils.UnitMetrics` is a generic lambda node that: - -- Reads `golden_key` and `predicted_key` from the graph state. -- Iterates the configured `unit_metrics_map`. -- Instantiates metrics via `UnitMetricRegistry.get_metric(name, **params)`. -- Writes per-record results back into state as `_result`. - -This is why most eval graphs: - -- Add a `unit_metrics` lambda node. -- Include the corresponding `*_result` field in `output_config.output_map`. - -### Aggregator metrics (generic `MetricCollatorPostProcessor`) - -`tasks.eval.utils.MetricCollatorPostProcessor` is a generic graph-level post-processor that: - -- Loads the run output file (`output_*.json`). -- For each configured entry in `aggregator_metrics_map`: - - Selects the unit-metric column specified by `unit_metrics_results` (commonly `exact_match_result`). - - Converts dicts to `UnitMetricResult` objects. - - Instantiates the aggregator metric via `AggregatorMetricRegistry.get_metric(name, **params)`. - - Computes the aggregated metric over all rows. - -It writes a new JSON file named by replacing `output` in the filename with `MetricCollatorPostProcessor`. - -## Outputs and artifacts - -An eval run typically produces **two primary artifacts**: - -### 1) Per-record output (includes unit metric results) - -This is the main run output file written during graph execution (typically named `output_*.json` or `output_*.jsonl`). - -You’ll find, per record: - -- The original fields you mapped in `output_config.output_map` -- The model outputs (e.g., `predicted_answer`) -- **Unit metric result fields** (e.g., `exact_match_result`) - -In the eval examples, `UnitMetrics` stores metric results in the state using: - -- `state[unit_metric_name + "_result"] = results[0].to_dict()` - -So if you configure `exact_match`, you’ll typically see: - -- `exact_match_result`: a dict representing a `UnitMetricResult` - -### 2) Aggregated evaluation report (aggregator metrics) - -After the run completes, SyGra runs graph post-processors and writes additional JSON files. - -For eval tasks using `tasks.eval.utils.MetricCollatorPostProcessor`, the report output is: - -- `MetricCollatorPostProcessor_*.json` - -This file contains a list with a single “report object”: - -- `evaluation_summary`: counts/status -- `results`: a dict keyed by aggregator metric name (e.g., `accuracy`, `f1_score`) - -## `MetricCollatorPostProcessor_*.json` file format - -The file is a JSON list with a single report object: - -```json -[ - { - "evaluation_summary": { - "total_records": 1000, - "status": "success" - }, - "results": { - "accuracy": { - "accuracy": 0.689 - }, - "precision": { - "average_precision": 0.54, - "precision_per_class": { - "Music": 0.91, - "Politics": 0.92, - "Other": 0.45 - } - }, - "recall": { - "average_recall": 0.72, - "recall_per_class": { - "Music": 0.81, - "Politics": 0.56, - "Other": 0.72 - } - }, - "f1_score": { - "average_f1_score": 0.62, - "f1_score_per_class": { - "Music": 0.86, - "Politics": 0.69, - "Other": 0.55 - } - } - } - } -] -``` - -Notes: - -- **Top-level** is always a list (currently a single-item list). -- `evaluation_summary.status` is typically: - - `success` - - `no_data` - - `fatal_error` (includes an `error` string) -- `results` keys match the `aggregator_metrics_map[].name` entries from your task config. -- `results` can contain **multiple aggregator metrics** in a single report (e.g., `accuracy`, `precision`, `recall`, `f1_score`, `pass_at_k`, etc.). -- For classification-style metrics, per-class fields (e.g., `precision_per_class`) are keyed by the task’s **label classes** (for example: `Music`, `Politics`, `Other`). -- The exact shape of each metric payload is **metric-dependent**: - - Example: `accuracy` returns `{ "accuracy": }`. - - Example: `precision`/`recall`/`f1_score` may return both macro/average values and per-class breakdowns. - -## Configuring metrics in `graph_config.yaml` - -Eval tasks typically implement **unit metrics** as a lambda node and **aggregator metrics** as a graph post-processor. - -### Unit metric example (per record) - -From `tasks/eval/question_answering/simpleqa/graph_config.yaml`: - -- `lambda: tasks.eval.utils.UnitMetrics` -- `unit_metrics_map`: list of unit metrics to run - -Example: - -```yaml -unit_metrics: - node_type: lambda - lambda: tasks.eval.utils.UnitMetrics - golden_key: "answer" - predicted_key: "predicted_answer" - unit_metrics_map: - - name: "exact_match" - params: - key: "text" - output_keys: - - exact_match_result -``` - -This writes `exact_match_result` into each output record. - -### Aggregator metric example (dataset-level) - -From `tasks/eval/classification/simpleqa/graph_config.yaml`: - -```yaml -graph_post_process: - - processor: tasks.eval.utils.MetricCollatorPostProcessor - params: - aggregator_metrics_map: - - name: "accuracy" - params: - key: "text" - unit_metrics_results: - - "exact_match_result" - - name: "f1_score" - params: - predicted_key: "text" - golden_key: "text" - unit_metrics_results: - - "exact_match_result" -``` - -`MetricCollatorPostProcessor` will: - -- Build a DataFrame from the run output (`output_*.json`) -- For each aggregator metric: - - Pull the configured `unit_metrics_results` column (e.g., `exact_match_result`) - - Convert dicts to `UnitMetricResult` - - Instantiate the metric via `AggregatorMetricRegistry.get_metric(name, **params)` - - Compute `metric.calculate(unit_metrics_results)` - -## Programmatic access - -- **Unit metric results** - - Read the per-record output file and inspect fields ending in `_result` (e.g., `exact_match_result`). - - These fields are dict-serialized `UnitMetricResult` values. -- **Aggregator metric results** - - Read `MetricCollatorPostProcessor_*.json` and access: - - `"results"` for metrics - - `"evaluation_summary"` for counts/status - -## Extending evaluation - -### Add a new unit metric - -- Implement a class under `sygra.core.eval.metrics.unit_metrics.*` inheriting the unit metric base. -- Decorate it with the unit metric decorator so it registers (see `UnitMetricRegistry` in `sygra.core.eval.metrics.unit_metrics.unit_metric_registry`). -- Reference it by name in your task YAML under `unit_metrics_map`. - -### Add a new aggregator metric - -- Implement a class under `sygra.core.eval.metrics.aggregator_metrics.*` inheriting the aggregator metric base. -- Decorate/register it (see `AggregatorMetricRegistry` in `sygra.core.eval.metrics.aggregator_metrics.aggregator_metric_registry`). -- Reference it by name in `graph_post_process` -> `MetricCollatorPostProcessor` -> `aggregator_metrics_map`. - -### Add a new graph-level report - -Graph post-processing is generic. - -- Implement a `GraphPostProcessor` (`sygra.core.graph.graph_postprocessor.GraphPostProcessor`). -- Add it to `graph_post_process` in the task config. -- SyGra will automatically write a new file by replacing `output` with your post-processor class name. - -## Troubleshooting / notes - -- **Graph post-processing reads the full output into memory** - - `GraphPostProcessor` runs after the graph completes and loads the entire output file. This is appropriate for evaluation, but avoid it for very large generations. -- **`MetricCollatorPostProcessor` expects the unit-metric field to exist** - - If the configured `unit_metrics_results` field is missing (or not included in `output_config.output_map`), metrics will fail with a `KeyError` listing available columns. -- **JSON vs JSONL** - - Current graph post-processing reads the output with `json.load(...)`, so it expects the run output to be a JSON array (`output_*.json`). - - If your run produces `output_*.jsonl`, you will need to either: - - Configure the task to write JSON (preferred for eval), or - - Implement a custom graph post-processor that can stream/parse JSONL. - ---- - diff --git a/tasks/eval/agents/web_agents/chat_history_seed.json b/tasks/eval/agents/web_agents/chat_history_seed.json new file mode 100644 index 00000000..b93e097e --- /dev/null +++ b/tasks/eval/agents/web_agents/chat_history_seed.json @@ -0,0 +1,8167 @@ +[ + { + "id": "mission_01_2", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 2, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 146.44, + "y": 94.44, + "width": 82.04, + "height": 61.11, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_3", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 3, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAPoCAIAAADCwUOzAAEAAElEQVR4nOy9B3wc13XvP3f6bO/ovbN3iqQkUlRvlqziJsc9Tk/ee6n/5KU9pyd+cYqTF8eOHdmWLMuyeu+i2HsFARC9Y3udPvf/OTMgCDaJtEALEO83sAIuZnfvzM7OnHvu7/wOarv3HykCgUAgEAgEAoEwv6E/7AEQCAQCgUAgEAiE94cE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgATuBAKBQCAQCATCAoAE7gQCgUAgEAgEwgKABO4EAoFAIBAIBMICgP2wB0AgEAgEAoHwUQMhhClELRAQoihsYbyQ9gUhClsWdZVBAncCgUAgEAiEOQUhQ9c5GtOIukgwPJ/AlG5RiGFpGl0gdp+f+4IpDcbMMfNqVFceErgTCAQCgUAgzCXYsnhRVE36oknseQWiBJ6iTN2yMILc+wLYF4QokaewqZuWvVxw1UACdwKBQCAQCIS5BGFc19JwquQryuYCSAkj1BDBhaGuZKrAcSw+K0BHNGXVtzZ2F7yKYtCgmfnwwZhiGdQa1lIDp5I5maOZs8f8UYYE7gQCgUAgEAhzAwJhiVFWXR4oi/1Kg4+lF0BESSPqVFw/oVcXCj2Gac0k3Z19Ka+tDMViv3aNl0YWJOfnA5hiaGrvgDw6kXEpo6qB58ewfh6QwJ1AIBAIBAJhbsAYcyztiZavrnM9uITyCLQ5D+s6zwFR2/uYRK48Pjpm5PIz0hOMMcvS3mj56nrpgcWUW2AtPD9CZETRFFZ1rm+sTFWScrbEMFeLTSIJ3AkEAoFAIBDmAISQaZo+v4flxds7eMXExSI1/zEsal0dt2fI6PH4tWLBxGf2JeD38rxw+yK+ZOCiMV8WDzBFsTS6oZkdSvnfGBJoqgi+NwtgbWMOIIE7gUAgEAgEwtxgWZbg9jSVSQJDWRaosedFivo9cUZYE2QjIX9ucnTmccuyRI+nsUwSaEoz7Xh53qAZVKWXifm4lEL5acqkrhauxsCdRghOUgynKgbm+PXh5cFclLpY/TWNEE1TJnyf59OXgEAgEK4yEFyQ8Uzggp0fPC/K7wgLF8SwIQ+jGpijQT4+/6EpStYpN0+JAofP1rHTLBfyMIqOaXoembcgCoIomoYfVQefShK4f5TRTYiondCdpinmgq6lHwDLwiYYKsErn/9XZA/A0CyWoS+4AYFAIBB+DiCKsihKMxkLLEDsR2zhLEtb9PzKLRIWGhibJsUsqDs8TcPXwTwvHsKwLxC1zzcQggFbGI7zVfVtnX8fxZUEOb3BnMmknXaH5Dc637R0Lt7o9Hud9zd4FNuRPYFAIBA+LBDCzi0QYwpT0BjSCVpo+08f9ugIC5uFeIt3QpcFtC/I/rnavqtXUcYdIUo3LJamlzSGBJ6xLMzQqG8s1zuSjQQkGiHzA9dKI0SZJg77xPpKb6Gkdw1nKQreZWYGSyOUL+mr2iM3rKx6adfQaLyoGxai4bZBIBAIhJ8bHG0lFCkqFm+pHK1xlby8SVEoqzEDBfebE1VZTQwJig6Z9yuOo650UkgwhcDQd57cFAgEwtUeuGNMMQzauKT8xjXVNI0sjBmE+sdzh3qSR3oTqmHy7BwY+BuWVVPm/di1DbphPvnOwLHe5MyqBoT1Fg75hDs31N25sY6h0Y/f7B2PF7l5uARFIBAIH2kKBtfmT18bm7ipYqTOXfTZgXtGZfoKHjdr7YzHRksekXHcNa7wcr9FGaap6aZhYoZBHEPzHMMwyLJI8E4gEK7WwB0hpBlmRdj1C7e3NlUFFNVwEuEblpbfsVH7P9/de7A77mQ7PtC7UMiyqEhAWNkSCfmEZFaFwH32GHRjeUt4/aIyRTW2rq5+/cDo0ESe56+ijl8EAoHwoWNhFODVzzV1bSmfMi1Gw3xcgccRouo9yi+3ddV6cv/RtdiuebvCI7ELAQWOcYusnVGiTMsyTGyYFvgoEAgEwtUZuNOI0nSzOurpqA0VFR0himVolqEVzQx6+K/cveiv/nv/WKIocMzFrGAuHUQhmkYMDUufF8j6w4QBGyaGdVGwHf2A70YgEAiEywAuzJj6XGP3xliCRpSFbBOZ0+VPNMIMjbdWTGY08XunWgWQVV6pAJqlkWpYXpFvrvJtXl3VXOXrH893DqR3HB0fmSpG/KJuWlforQkEwgLlKhJpWBYlCgzL0iXV4FlmJF7c1zXFMkhWjZUt0foKn3n2oqht2gg/F8t6wCXe3uCcAN20sKabsmaq+rQ9kV2oChtxLErlVJFny8Mu3bBkxWAYO36feU10+n3Pe1fHpgbmA6dzQLYm8qJ3lDMvdUFzm1l/Pec1zvQ6tn8/ZzAzTyS5IAKBsOCgEdYs+trY2M0VYyKDSwZrWmh2lZtuoZLBeljrzqqRteG4atGOX+Tcj4RGuZIuCcxX71l035amJY2hkmwEPMK1y8v/6POrV7ZF03mVYeifZ3LngvkmAoEwr7iKAneEKMPApmlxLD08VXh5z9CT7/QfPpVgGKTpZntdkONoa1Z1sm5amg66QwtfoKTaucQ7G+jGWUkRCG3PjrCnVz/tNdF4Wt57Mt47kjvam0jnFJahDQOUjM5bWBbWTUvVTN20Zr+po4NUNJgPaKfnA7phGRfPx8y81Mz2F/srjOs02B6qcw8DZyjLOmcHYVpiwIMkEUQgEC6zBNP+5TyTinP+NPtnbqEpSrMYH6c+UDfg4SzZYFl0lsGXnXGnWIQLOhsRtfvqBkTGNKwrUoeEMSWJ7MeurV/bES0q+tsHR//tyeMv7BzsHckub4784t2Laso9sqJfIdfg8w8vpqiSamhn387OesqVGAfh8sEf6UEuiL37cLlapDKzi/cRhV7YOfiTN3sRjXqGM9/7o62maa1sDT/2GqtoxnQuGWr87RMIEsygfgG7sLNeazrjDi5i73eDsTs+wRYMA1fGv3/k4MqWyGS6lMpD4A6m8mdMKsFj5kIWlSCrmX676SYIiKYveoZPb2C/FLz32fL90391/ucMb3r3nKHCm1GwfGwfrekddMZJwxGBPxKfYwKBcOnYV1H7vjxtn3Lm+uFcHm1LxjMrfs625154P+AYEJZ1Zmt5oiOQU02WQRcNUlnaUkx2ZSi12J/eGS/3cRo154IZjLeuqv7sre3fefbEs9sHeI42DDyRKu46NnGiP/2/v7DmUze2/N0jBySRvRKtZc4c8zOP2Bn395ijfNSN95xTbwHoV08ruz56g8QLZe8+VK6uwH2GgqznSprEs4mMPJVWykJSW01A5OmSilkaGSaWFWNpYzgaEDXDOtyTSOaUiF+E3LsNy6CCrPMss7wl4hLZTF47fCrBMkgS2AunVQRW5BjTwhxLlxSjIOv9Y/lEVtEMjBCO+qWJVEk3TJfIeV18edgVDYgTyVLnYMYtsLppMQyVL+kRn7h+cZkkshPJ4t6TcU0zVrdFZc3sH8ueE+XTCBmW5XcLFWFXyCcUSvqx/hSFob2CaYG4v6hoYZ8UC4plIZeimSf6U4puciyt6ZZH4twi1zuWlQTWJbA+F99Q5SvK+vG+lLOA4HfzVTG3yLNHepKKbnDsz3Ull0AgLNDVzmQB8hR+D58vaiXViAWlmTgwkZVpGgU8cLEqqcbMEwWO8bn5D24bMD0MCusWHRaUG8rHWJqSDYpF79mXEVNezrq5YuRIOmTMaarC9ibGATf/lbs7Xto99PyOwaKsazrtLGQiCu06MfnX3z9w89qadR1le05MBr2CMaf2NhbGyZzCIBT0iTCDsj8JhkH3bWk5OZA60ps8/8JuYaxp4L0GZVrURxNVg4Vujv15KBEMk7JOzwURQpf+nghRbh7JOj7fc8huR/AhNGq1NQUQO1n2ABgavlmCPcjL+uZiiuIZOBSy/lE9xeaGqzRw90qc3yPwLPTbSuaU6qh7aDJvq1OQaWKWobesLN+ysjLgFUBFUxs42BM/3p9i7FwEjVBJMcI+cfOKqjUdUZ5jiopRFpR2Hp9QVPOcRDlDo5JqdNSHtq6qKsq6wDNPvtO/dXVVQ6Wvezjzyt7hiE+6f0tjMqu8tGswFnJtXV0V8IplIal/LNc9nFE0U+Bpw7KaqvxbV1Wt7YgJPJPIyNmiFvFJt2+oPdid6BvLzn5P2ypeW9Yc2bKyMuQTAx5eN3DQN/zqnhGepzmGzpW05c3ha5dWBLxCNChaJlUd8zzxZi8FljhWech167ra4wPJbYfHr1te0VoTqIi6LcN6lmfeOTy+YUn5hsVl4YDoc/FRv/TK3iELY3o6kUYgEAgXioBN7HVz16+oLCjaoZ7kqrZoXbn3tX3DlmUv5VHUnRvrFM062B1f1hypLfOY0LwRyveTWeV4f8q08FwJr3WLbgvIy0PZkskzzPtk9qAJvCmsi6arXPJAwcPTcyYPRBRVUvS17TFEU9959kRB1gNeoSgbDRV+C1sTyRJD04+/eSocEO+5rvFEf1q3HWbmKkWCMcyI7tpYp2rWns5JjoWjq2hmR1XoUzc17zg8sb8rzrNnrec6T6mOehJZBdalP4o6eExR5RGXZeJ0Qb3Su4cQFXQjxwkaU5Sq46J2ST0ZYQ5sUidSeoWPEVgIlGc/ibE7wetX3ML0LDCmOIYKSkxRxwIL3hslDZd0PJAyK/w0x1zGecsgKlm0CqpVFWBIQvA9uEoDd1U3S4pusJbfw0s8w3P00f6UrJkMjQwDr2qLfPWeRfXlHg3mi/iG1VWHe5J/+u3diazKsZDMlgTu5rW1v3Bbq1viDMPieXpxfQghtO3wmK6cq3dXdXNFc/hzt7WlC+p4qvTo6z03rKq6fmXl4VOJfSenass8D25tEnlojRwJip+8saVQ0hkW1cQ8O45N7OuMG5blEblP39R8y7oa03Y3aKjwJbLKssZwa21gKi2fs2uGZfk8wl0b6+69vlFWdbjg8kwsJJ0ayY7GixbGPEt/8sbmG1dXq7rpLAI0VnkHxnKHe5O6gaNB6f4tDTeXqk0TP3BD0+KGULaoeiVeEtmByfxdm+puX1+bK+oCT9eWebqH011DWZGniZ0lgUC4IAghwzQjfum3P72ibzx7sHv7nRvrPntL6yf+JNs5kOY5MMP9H59YPpmWD3THb1pT/dAtLTosRSIa4aP96b/5/oHBiRzDzslFBl6z1Z30s3JOg4ji7HGeXqafecR2jQxyRps3MVDwUHOHaVE+N79pecWPXu1JZpWwX5JVo6nKd+OaatPCP3i5C1FURdi148j4vdc1rGqNvntk3Ovm5uQyC8kpy3JL3P/4xPJ4Rn778BjPwd1HN3HYL4gcE/KLzoYzx8I2MjarYq5Pbm3+8ZunBsbzDMRn1EcJjCmWpTevqDR06+nt/XPfTf1sLIuazFm6naBGiBJYJHEQhb8vDKLSKv7uruLn17nbyjhFPyvcNy34HJmfb+kiDX0nqaG0OZAyAhJd4aP9Et2bMH64t/Qbmz0xL9LMS1K+WJiSeLS3Sz06qv/2jZ6f7+xjgXEVFafORtPNomJkC9raRbHqmAdTlAgXL7hye13cQ7e0Vsfcmg6rZghRsqK31QZuXleD7DImVbe2rKr8zC0tPMeYJjgOGIYV9PJfuqt9ZVtENcyZmlREUZphhn1CW11AhTJW47ntA7ZxO61qZtAr+ty8Y9ZbUo37tjRuWQlZedPChoF9LjCprK/wpnLq4sbwHRvqTNOCbq8MXHY3LS0vC0mGdVYBq62hB5Oce65r2LKqqqRA0StYXqpmfbn3Kx9b5JLYXEm/YVXVmo4yx/EGweKg6XHxf/qlNdVRt6yZNKJ0C7tE9pfuXVwVcSuqgSi4anfUh37l40tWtUZkWMjGqmZVx9xrO8ocTeCH8iESCIQFgXOBgLjTmla6WxjffW39TL0jRIGnG1dD1yGEwG6LRm21/lvXVdvOKnMgMLcwEhhjlW/I0DRkKpShzvxgXaVMFZn2L7Mep0wF6+py39is/tcfFBohVTc3LClf2x491JMUBUbRjICX/8PPr75uWcU91zbcsq42b0sxJ1PK2FRxSWPI9q+c48usZZ15ScvCksCc6E/t7Zx6+9CoUw7LMjTHwg/ks0yrKuL52LUNFWGXnW4/fY9DyEnYOzA0Yu2wEbQf9tNZZtq2zJGgzFRzsQw98y7Os+wtp19nZoNZL3Lm9Rka3tR5yPndGeT0GJgz28Bms4Qj0NyKhWXnmQen3wU2owJu/vrlFTeuqYaleNsweuY1aft952SdwbaEpoqa9Y03C7/2WOa3fpL9nSezPz4oO0UHeDr4hv/OMPOIXTaMcrL1Sqc6kDZ5BrLvummrbjDFIDSRM/cOaaox/blaGP5knP6g4Z/W9OvM1clkYfDK60+Zf/x87i9ezv/eU9nHDiouHo1krKePKgUV1sqs0+N3fpw9cn50e+QzLyWy6OCI9nq3SoH2ZnqohnVmG8LVm3G3MN68sqo84qYwtbwl4pa44anC7hOTNE2l89qNa6pXtkYUKK7HRUXjWVriGZbFN66pfmHHULao1sQ8d22si/gFVbdKqikruktkBY6pr/DdsLLq7YPj05JB+wLN0PSmZRUddcFMQcuXjJd2DZmmpetWUdEt0ITRpmkpmllSjUhAsiws8AzP0pmCpunW8qaI183RCC1tCrklNlNQgz6hsz9dW+YtD7lSeVXRIGU+s180jWTV9HuELSsqPRJn+8bgzsF0Wy1MG1a3ReFqSKMtq6p8Li6dUzXDRAiVh6RcUa+v8N2yvtZZlS4pJsdQlRE3RVG5ouaRuKKiiwK7tj3mkdiibLgkriTrqm6tW1T23PaBvKyzl7McRiAQrjYsjEuKrmiQL1A1M1fSlzWFo0EpnQdZQkkxZPtPmm7lSvqLO4eOD6QWN4QevKFp3aKyn7zVl8opHMt8wOAVQ7dsuvmaWzQJnSUEgSgNpdMKQigYFA1IapwJ0QyGaq6kcFdpDgvmTFv92D+eG5kqSDxbUo3b1tcyNPrWsyfu3lh/3bKKZ7b10zQ07DvSm1zdHvO6YWkXbCnnTi0Dx1w1pydLcGug4xnlX584msopPMcYppXNaboB8tGoX1RUo1DSy4JSvqQlMnJlxGNgiMlUzZjIqxG/BLEujbJFTVaN8pBL061kUQWNk126wLO0opuTKTnoFQSO0U0rlZc5lnaJ7GSqJPCMbkBayu8RQL4K68Y4lZdZhrZsb2WWpQMegWFQrqgpmukSIQPld/Nu+xdZMTCFRZ71uXmKwumc6qTPS4qOKORzc5LAwmI1ojJ5TdEgFeV1cS6RNUw8kSoJHEimCiWNRcglgIQ/npY5Fqm6JfCMR+IQooqyUVR0jwQvNSfrHqZFdU0ZsoHbY+xQ2njxuNJexm2o53ULB1y0xFElDedVxx2D8kvIxaOSNvNP+vdu9LVEWVnHfgl5RUjVx/OWT0SpEv7JIfnGVgFTVF7BbgF5BfhrumTpFuXikAh5fcwzKCNbBsyiP+BpZEt3LPzKSaU7rt/QLPYljWeOyhsbuI4y5g9u9gZdtG5iF4/8ElINqOtgGSqn4IAEs3faXmrIKli11w1oBHt9U5uwqIwzMRVwIdOalrxnFayZV6yZwgLkagzcMcbrF5dtXV1NUVQmr2ILj04V3zo4hijIZ1+zpMxWE+IT/akTg+mAh9+6sgojqq7Mu3FJ+aOv99y/pam9LliUDVkzth2ZSOeUugrvNYvKCiV9aWO4KuqGi53tmyCrZkk1b1tfG/KKmMJ9Y3Iyq7hEjqJg+g7GixhWhJ3cQFHWKYo6OZiWNbMm5pYEzjQtF8+FvMLy5nAyq7pE7nhf6rkdg4vqQ1tWVFK2rftZBgwYswzauqqqEjLlZq6o7u6cOt6fCvnaq2Nu04Dr7DWLy9rqArpuZovqWwfHORZ11AVaqgOj8eKWFZXfe74TphNw6cRFRVc1c9vh8cWNofpyr6KZLE3Lqrnr+CTL0hsWl2m6FQ1IHonLFjVYwCMQCISLAI4lp1OY4JaLUNAjrGqNPrt9wOfiGQad+RNNbz86/tS2vo1LK1a1RWtiHq/E2bHUBx0DprAksr4lt1McP3sOQCNqIi7nkAoi+JAYDUvQ02Mm+0vTgWxBZJ+xl2DnADAJMHHIJ+w5MVVSdZFnOZZe1RZ9effQw892Fkr6V+7qiAalXFFjGHR8IH3L+lqvi4+nZX5Oqw5njrmz8m5aVtAruESWoV2TqRLP0StbIxLPWhgPTuQDXqGtLhjPyu11oUxeG0/KDOyFFfKJq9qi3cNZVTNN3Wyq8gc8/LG+lEtkW2piLEObFjy9pBp+N7+8KTIwkcsXdVFgmqujJcVIZJX1i8uyRc0lsCxDj0wVYGqHKJGf3oBjkMfFKZo5OJHXdLOh0ud38/GssjrsGokXk1mlrswT8okQlBe0sXiRpqmO+qBThxYJiBhTo4lCJg8JONPCLdV+v4e3MDWRhOdKArthSVm+qLMMLQqMS2CdG+rq9miuqAW8Qq6oTaVkE+OKsBQLhSdTpVROZeeiNhchCMc3t4h3LZa64/o/v1V86YSyuYk3TKpnSk8WrZiXKfNO1wcPJM2pghXx0NgCNXnITa9v4GMe+PBGs+b4kMkxqDHM5lRrR592aETf2a+1xNiARE/lzUMjFsdQDWFWZFG8YOUUi6OpnIrrQoxwjlbs8sEw36PiBWtnn3rXYulXr3V3Thr/9438iXHz48uE65sFiQNbu2TROjRiekXk5lFRwzUBpiduMjRE/FkZ1wQZZ3YBXTIN3BrjqgMQx3dNGiKL8iqE7DUBRuJJcvDqDtwpJ8FjexeYJpYElueYoIefSMpNVf7KiEc3zGxRf+S17v0n4wGPEISOGBWIou7aVPed5zsXN4ScxbvX949+8ydHNcNqqPTWl3urI56QX2yrDSggOJm+CQXc/JKGELivMPTu41AG5LzvaePFaTCGXPtEqvSXDx8Ymsz/6ZfWXL+80sK4LCiF/VJHXUhWDU03v/nEsc7B1Mu7hoMeYd2i2NkOj0g3zFhQuv2aOo/E6iZ+/K2+R17plkTG7xZ+88GleTtrfseG+lhAMgxr78n4t54+7hIYn4f/+1/bWB31hP1iTcxrzyVgFdXn5t8+MPCPPzp8+4a63//sSoxNnqd7hrPf/OmxXEl79M9uDvtEW7xDvkwEAuEyQGCpYbkk7rrlFc/tGDzf8NEtcbGAK56RD59KLKprsd1p5+BNMaZiXsSYMmXBWvz04whadpw4MBoMCqaJJwb18LXVZ/5KUZimOaxEvWgkDWHKnFzvMKbKQ64DJ+OOcIhj6FOj2f7xXHnMM5EqFVUj7BcTGYgs+0Yzsmp4XfxEskRd0ToEw4oFpT/50to9J6b+4ZGD7fXR3/7Uyoqwy8LW3z9yKJFVv3x3Ryav/uLdi1a1RH77X3cEvUJBVtd2xL7xW9f98j+8dag7oermZ25p2bC4/Pbffm7D0vJfv3+pV+JKivmNxw69um94SUPo337n+t/8xrZ3Do1VRYO//9DKo33JR1899adfXHugO95aGxB55k+/vadvLIcQCvvE3/n0ipGpgt8rLGkIjUwV/v6Rg3tPTP3SPYtuW1/3/I7BL9zZ/mff2fvqvuHP3NRy/aoqlqZ3n5j8xo8Pp3LKF+/sCHiE3tHsbdfU6ob13y90/viNXpahgx7xK3cvWtUWNS38o9d6Hn7ppI+l/+IX1x/uSXrdXFtdcGgiXxl1Iwr9/mdXvbZ35PYNtUd6El//0WHNMG9aW/2JrS3/9OPDr+4b4SVu9kL3z3zIdZMKikyln2mIMM8fUwdSJstQkwXr2zuL+4f065qEr2x0RdxMomA+vLf0To96Q6uQV/CSSu7WDuGPn8/+9g2eVTX8Tw7KL3cqIov+v1u8bh49e1yWWPRPbxd/a7N7UyP/wnHl6SOKR0C/tcVzfbPwRpf+9FE56qZ7k8bX7vJV+Rnd/ECtEuzAHaWKWNap1TWcwKHlVdwnV7kq/cyJSeMfXi/81d2+cj/zUmfpB3vk5dVcTYCZzFt/dKv38UOyBq44eEe/9tVN7tsXQVmFacFk5ieH5P1D+j/c5390n+zmUX/KGMmYv7jRvaVF+MDH/KPD1ahxhyQ3Q0+llcmMIgqwJthY5btxbbWsGo1VvpZqX0k1Xtw1eORUEmM8mSq+fXhMNyyMcdgv+t28bpgCxySy8rYjY+m8YlpW12Bm17FJw7R8bg4cJHXwB5ZV/drl5X/+lXVOnqlzKPP6/hH2Yh65oHtDezunBsZz+ZI2Y7bA0KgaZtaIZdCu41Odg2nDxLmStvPYxAW/b9CclaMFnomnS8/vGDAtrBvWy7sH/+r7Bx55tVvRTJ4DhZ+qmU+902eYVkk1xhPFI6dSPAeDrIi44MtkK+NTOWXH8Yl0QT0xkEpkZZZFum7tPDYxGi8WSvrIVNGycDQginZKhtiuEgiESwFTsPRXUg1FM5c0hle0RAryuT2GGAYJPKNqpqwYYL0+Jw7qtqckJGfBccCi7B+MLURZ6VTJMg1sWQyDdc3IpEvgazdrGxphr2ALbT/wOBxpgd8jSAI7OJV3+pRaGD/37sDJwYwoMF4XXxVx28564BwwlVZKit5Y4b2yCRIEYxB5tizkCvtEjqVvW1+7tDHkkdiyoOvTN7VGfILPxdsLBWLIJzpNCZ2kjd8DySlMUZGA1FIdoBCuCLvu39LUWh2ojLibqnyfvrkl6AUz5fKIW7BtkcEvISiFfKLAMSGfuG5R2arWaFlQcqTnloVFngnbj69ui1ZHPe11wQduaC5phs8lVMU8N62tLq/08TyzsiV649qaqoirKuYGefpqqOwK+8X2usAta2tqop6aqOfuTQ0tNX5FM69dDk5xFRF3fbn33usbFtWHFBVqple1RTcuKS8PufweAbTyDKoIu/L2Aviylgh00jWsRfUhj8RNpUG9M4eNBTgGCRwVcdM8C5M5lkYvnVDe6dWiHub1LnVHn87Q1L5h/fljildEB4f1d06pmgGa78GkqRr45KTxVo9aE2Blg/q3bUVIFIpwAMNuOuBC+0f0p4+A3Dwl4//cUZLtStj9w/qOAd3DI2YupqDOqStxoE1/q0fNKVbMQ29pETrK2ZyCexMGTVN9CeMHe2SeReM581lb9a4ZuKTiV08qQ2mzpOOXO9XJnAUtFUB8RSUK1mDatDDOKtbzJ5SsApKhJw7CE8GHlOQJr9rAnUboYHf8sdd7Hn/j1LbD4yXV9Lm429bXxkIg1PO7edPCw/Giopkhn+iRuKO9yeHJAs8xuaLeXO33uXmMqURG6R3N+dx80CuYppXIKE6rppBXFHjW/rbjunLv5pWVqm6KPPvO4bH+sRxzEUkJ6Ooyyuv7RkSBiQbEgqw73UxNjN0Sq+lgdzMaL2KK8kic383D212w6sVW4GBMDU4WJtOlaEByCWwiqzy3feD5nYOOw4xpWVMZuX88F/QKfg/PsUz3cMZx7a2MuO33hevmWKJ4qCcR9gmqbtqm9XRR0bcdHndLLNgty4aJsdfFscTHnUAgXBZgaYffPTIeC7pWt0XtVm9nUZKNRBbWPzvqA7kiSJbnCgGEinZt5XTbPIRour8/5/EKo2PFqSnZ5eb7B3IMy0A17On2rQghgZsb01t7adSqikKHjVxRcx60MOWkbDiG/sTW5pJijMSLYMiIITAajRehL9LPpflRsaQXFb085Fq/uOxIX/LP/2vf8zsGV7VGirL+1Dt9fg//9La+J97qE+E+4uR31K6hzJL6EKKo6qg75BUOdMUbKrzXLi1/++Do1x899M7h0U3LKlprA7phFgoaaJCcN1IMVQcvhExBDfuEJ9/u+9Yznemc6tzCnF4rbpF7+8DY3/7wwESytGlpeU3Mky/phgFVYV//3r4TA6k7N9YJPPODV3r++fEjPMtsXV0dDoiZnOKRuMl06e8eOfjKnuEljeGW6gBCYDk6lZG//ujB/3z2RFOVb1VrFFNUKqd6XdwbB0a+/uih57YPJLNKKq/84OXuHcfGByfyPjfPgXwGBb3QWaVnJMtz9OxG4x8ERFFp2ZwqmK93qafiRm2QTcvW9j71plbxa3f5llVx7/RqJR3v6FMr/MxvbPZsbOTzKkTJFAWBssDSB0fA9//3b/Z8daNb5FDEQ1/XJFiYum+Z2BRhd/RpDE39wc3eL13j6k1A3toj0EXVuraJ/4V1Lq8wBztimxFRFX66Kco8d0z5zs7S9/eWsopV6YcSEkd5dGxML6j4S9e4PrZE0k3wjbHArJ3iWOrWDuGL613Hx43hDBTaOmcGS1M8CzGMyCHTwp9aLd21ROyc1DOy9XN2y5nPXKVSmXcPjz3+ximOZY73pvyfENxisDbmbajwURTSQKEOBdocA/U0LEtn8+rQZGFZc9i0rJqYJxZ0OZlsVZ2upqJpmKZjbPfU8AoeeynNkdnZ9TFwgRuayJ/uF3ihkikajSVL3UNZKEjSzPEkxOhO6b5hQH0PxljiIS1lmJZhWgJHX8jeFQe9YmXEpelmOq+6RU4Dixrststr0gU1FpTKQi6MqakMSO0N02IwUjQzL2sIlJwoGgDXSKdUfzxRmkyWAl7QVUIFPwX3m76xHMcizTDhcmZPTogRJIFAuFwgubhraPOKyhXN4ZBP0KFQfvpPCFG15Z5lzeGb19WsaIl0D2eLsmGnPD7opQZW9plzLsIYIXpkJF9f7+/tzQgCs2ZN2chIfv36Kgq6lU73FrU9RuaoC9S0hQtr2feI6f47FEgTZRW6/m1YXPbt505MpkpBr+BUHOWhG83PyTidZaCTScgPjmfH+pLP7RgcTRQFjhmaKry4a+ihW1qf3znw7uEJSLqDlTCKZ+ShyXxLrd8wraBHKA9Jx/vT1WUenqWf3t7/+Bu9D93csnlFVXtd8Fhf0jn4DvZUBOZCPEunC+q//fTo8FTR5wHHF90+0BxL50va9144uadzsr7cd+PqqmVNYd2wOJZ+ec/wv/7kaNDLr26N9I5mv/3siXhaXtsWa6z0NVT4VN3iOPrFXUP/+sTRj1/feOOa6rKgy+/mF9WHn9858N8vdtXE3A/c0Fhf4XWLLMvALvz7T48f7U82VfpvWFlJM+iHr3Sn82pRMUSOhnUARHvdXK6k5Uua3yPMkToUTBuPjOkChw6P6JmStbGRH0gZk3nrKxuE5iizqpb70T45WbS6p4zbOsS7l0itUfbZY6pu12g6Kx6KbvEs8oj0dU18c5QJuuiGCNyYV1Rzbp4eSZuVAaa1jOVZKuiiB1MwcIFFn1sntUS5nGwvIH3AswrZTcoE+vomvicOCfVnj+L7VkiVfrfdk53SDepU3Fhbx9+5RGQQ2tGvyRrmaCi0XVLBPbBCysr4WztKqRIo753j6liyIoRUAy+t5O5fJu211xyyJQjMCA5X6RSGYWiWBUnJwERuf2dcsIvoOYaBlDPGpomHJvIMA/LDmVZkpgWm7wyN7DKpM2lmCLsZNJ4qqZp5jhDGsZRyfHMrQm7uPU3NYLvTt4YLmsjOKFJAg37epcMZoc/NRfyiYU7H+tNPhMVeWISC/M3pZ86++JwZtSPNRxCajyVLDANGTs4RcCT7MyM8Pc7LOuoEAoEA10xkpwb2n5xau6isttyrQ6NEp+gHrlQPbm3+u1/deOPqapHnDnQn4lmZgxQ49RHAvl/QqazSOZi2bKuT06B8ybj72vp3j44/v2PQ4wJbMNsCH1eGXc3VvjkR6rz/8OzaWbBLLunLmyKfva1lLFH8y4f3jyeLkgCO+44/o72uizmWmUqXTo1ky8MuTFEuiXOJ3NHeVF25N5lTJ1MyFG4l5cl0qb4cBJ/nf4CWhXmO6exL50u6JDCzJVEMjRIZZXgq7xLZI30JClFh22BeVo23D426Jdbr4kSBHZkqTiRLsKZ9dCzkAx96mkbprDo4kRN5ZmSqkMorlRF3JAj+ECyN1nREV7RGMgWtLCTxPCPy7KGexPAUJNftezWssLAs4mGukmcZuqUmUF/hDfvE/vE8ZM7mztWHodGhEf2RfaWDI1pHGbe1lZ/IWVkFv9ip/PWrhe29WlHFRRWnSzjsZkDIxKHqAKjSIYsGhRm4rYybzJl//Fz2rR613M9IkKKGF0eIyipWSbM6J4xvvFn47i45VTSTRUs3ccQDm+nQ4GxuYBB0Ob2mQfjdmzybGiHN99wxZc+gBhZQdtAyljMrfPCmNE3VBhndhC+4YVFBiRZY+MoHJVqBuu8zH71zplsWVeFndAt7BOSX6IzsxBxzNO4FzlUauPMsLfKsJLAUprJFDdEQUvs8XL6k2U6xqK7Ca0AjAzhNPBLnlsAEyjCsggxydye9badDQKJII5QpqJphCRybyasFWXdiXFk1Tw5lLAzp+RUtEVFgbIviCw+JpmE6Mf37rG3sqyScsgGvYEC+AW5gXre9YGbjLOcadiulkmKAFwEN2XGMIdR2roC2Fxu0u4OVPozLg5Jh+83bXU7sRQYoSMVj8QLsD8T3IOybLexBiJpMyx/JhnkEAuHnDMugXEnbfnTc5+K3rq7mWDD+c/6EKCrsE+vLvBVh157OqSfe6mXnyE3FLoo9Z40QEhzV1V7DsJqaAo2NfsOAf1ogI5h5U1hNNWb5zHzwYegG9rh4x7fbubqalhXwCMuawq/tG84UVDggp9dR+VmWBlca2yaBHRjP9YzmFjWEPrm1+VfvW7KsOSwrJs8ylt0/lecYZ2Oahq4mqZxCI9RY6YsGpZJqFGW9NuZJZBTZdpLJy1oyq1SGXU7V1jk3EKjjYtBURqYQkkBacdZfU3nFAkEmPzSRtzAV8AhgxWZZk8mSJLD15V5EoWxeZWiK58A4QRI4p6IsW9RSWdXn4lXdjKflioirvTZYKGkrmiO/95mVX75zUVnQ1VITcAlQdAa9YHXTI3GOzTxNUxzLuATm6KmkYYLetSIseV3c/q6pORW4I8Ok1tdx9y2XXDwq9zNRL63oEI5P5MzuSSNesCr8NEvbTp0MpRjYMCkXB/88XVGNl1Vxt3SIR0aN7+wqfX9PCUo37JhXM6mSig2Lysm4e8oYy5oCi0QO8n0CC/+1nVfnBqiIo1FTlF1ZzX12rfTr13ssi9rZr9krVLCBZcFb6yal6NjNTzeZcqpaLQwVuiJ3gRPD2UZkkS1rAC8d6EpDuMoDd92wNMPUdFMzIEtt2VmQgJefSJVME/M8s66jTNVMw8KOj5XThVs38akRmMdbFva4WFFgnEJS3bRqYl5JYHXDSmRlVTMRhrlB72juuR2DAgsmte11wYBtRHUxnBzG9O+zHgR9ub0g0FTlC3jBFIyiqKXN4ZmXgoZNJgZhj2oqmlmQDZpGPjdvYXDAZcDc3WAZurbMqxtmIq1Ai1a/GPSJsmqaJhyHoA+W/6BTsarPXF7Pt2ZP5eAyeoU+EQKBcPVgpzap/ScTp0YyN6yohIvw6Suaham3D47957MnVN1K59WJVMk2z52bK48KOgyIcCz7B2PLtKz6Bl8ur1ZUuqJRsVDU6up9umFSaHoDCra0rabnZAR2X3pZM6J+KKCa3QIJUsu9yYGxvNcuA3WSjiJ0EaF7hkDBeCWg7dzNdK55un09SuXUp7f1v7JnmGeZh25p/fX7l8ZCkt33A+KnM5+FBbe5REbJFrUNi8ubq3wD4zkTSktZA0SacCez7GVe8OC3sf3U7bea9XlCatbC51u1WLZdMti6G3A0GNqJmxFN0zo0LGcQVFhiGsGsz5GnzpS3nm5gBMvdHEu7RRZiZQurcIvU93dN7T8Z103IWDm5KtPOxDl9qSAlx9KnhrO6CbMpr4vnWaazPz27l9MHxDmSGxr539zsWVzO9acMRQefdZamtrYKD6wQP75M+Lgd0wsslSlZAZGmEJg/cnYm21HLRN3059e5vgzmM/SzR+TxrMnYjnASR0kcjLW9nLt/ufTgKvG+FVJzhIXPwtbYzNV+2NozcHt84bhimtSKGu6LG9xNUWYkY4/EXqUPuejRDAzbLaCBNPzifDLOvNQRAlwMu6vUtB/UnFqhLniu0sCdtgV2iKI8Lq465jGdbzlk3/VEVmFpurbMUxvzUvY1u6HSV1vu1eyamN6xbLag2W3k3EubwvbCGhW0vd69Li5TUFN5lefAMpbnoOjz3UPjdmcJcO1tqvLP3JwunZF4wbQvQ9VRz/UrKnkWFu/Wd8RgIdVeXbYsqizoWtUahdVV28wRU1RLtb++zGe3I4TL0OLG8ANbmwol/WB3Ahpc02jjknJnolAWdK1tj9k6H3ipGc7/Ojkt8QgEAuED4sSpAxO5bUfGokE7hJ3OWEBO7s39o//+1LHhyfzqtujqtlhRgTXMD/qWdsiSU0DUzkBRkv1DMzRFh0MuFsJjBlu0wLPhkAth2tmAtv+LMcqrdujwgacPjmdXMquk82pDhQ/b67fO6mhB1n78xilFn5b72+l2K+wTfG5hPHWlvCDtmwv8zCRlDBMHPMKBk1N//fCBl/cMnxxMV0bcHfVBZ7V4dgtXC1M8x/SMZFM58IVsrfEf60tlCmoiq/i9vMAx0CxJgL5I8ZzitCV0eirRdr/V9+2G63PxThVZNCg55arOsbLsjiVjiZJpYUmEijKMqIqwS9UN6C+OsVtkvW5O1cGrJOAVElmlfzzvFtltR8b+5Nt7v/6jQ996+vj3Xjxpr07DMM5qxmUvPtMI5UtapqCF/UJFxF1QdFiZB0eiOTvyCFElFXLJiyrYo2P6RM4q89J+kV5Uwd2xWLy1Q1xWyYkcqgkyR8f0kYzZmzQGUmDZ7vhPMAgNpU3VxF/d5P7iepfE0+PgzQIfaEnFXhF5BLo+zNy+SLypTdzQwJf7YMFkbqNfO4WP+pPGX72SH8maBRXLGpzPkl2DZ8+pqPowc2LC6EuYoxnz8IgusNPH8FJGMnsbkjKczdUYiiFEVUU9sYAr6BU+fVPLNYvLZBUy09mCNjSRH50qUBRVHXF//s62WNDVXOW/dX2tqkNi5siphMAxxweShZLOcfRdm+pv31DnFrjNK6tWtEQUDa4a6bxqF6pOK8GLin6sL2nr7tCqtph+aT08Zq4ODAOj6hxKQ/6boh66pfUPP7/6K3d3+Ny8aWcLMHh4MfdtbvjNB5d97va2wYnc8GSBRlQ0IH7hzvb6cm+moC5uDH/2ltZb1tSUVCOeATkgoqjbr6ntqA8G3Pwv3Na2qi3qdDTc3xW/xOTWzzADIRAIhHMsCPecmErlINkx+7Kj20617xwaKwuK1VG30/byA+IsJMbzWGRdfjHgE/3Oj1fwh93BjaubKkKR6mh0w6qmwOy/iv6AFOBoVzyP6TkycXdI5JRlzZHZXrqmhRMZBRZsncAd1BSW3yPkSxpMXeZapuhMDDIFNVvUMgW1CGExoBtWOCDec30jQtQ3nzj62OunWBYyWRCIYSSwzJl+qxgLHHNqNJvIyK01gcqwp3Mwnclro/FCNCCJIhPPyG4XGwtKI1MFjLFuWuUhF8TfFBXyCYZ9C7sYGEONLM/Sk+lSe12Qhhu0as/fYBwMDf1NDcMK+wWaQfmSvqoVuibphmWaOBIUowFxKiNLIhv1S+OJ4uBEzu5yaBw+lTjck4iFXG01gdMHYvr/O5NDnoNmiM4p1z2caa4KXLO4rHsoY1pn6bA/OBwDKlbdxIvLuYiL2dWvVQWZch/95CFlKGU+fVT55raCyKL19fxbPeofPJP717cLtmYMzkGGhl6qzx1XvvFWYSpvFjSsGtgn0i4e8Sy1vV8zMY566QPD2okJ/cCQ/vXXC8Np6MTkNKadQ0wLewVaNaiH95QGk8bzJ+ShlFUfhnIIjoZ9XFzBxgvW117K/dkLuVQJphaOdcxMGtBOJJ75ZjH2sy64DeHqdZWxRXJ4aVP4s7dC6en6ReVeFyR7xpLF/vFcJq8e6I53NIQYlt60tAJR4C3TXhdUNVPVzbcPjoZ8wq5jk/dd31Qdc7dUg0iuvSbQXh+kaYrF9L5T8YHxfHnIBSusdtKdoqg3D4ytaIlhbC5rClVE3YPjOfuidCY6d36fHS07nqZObiZf0nYcnVjeFE5klMqwO7xWBJXm6dpQzbBiAemWdTVVUc+Nq6sffaV71/GJFS0RhKhrFpchijo1muuoD3bUBf0evrHSf3IoM54oCjxTW+b59M0t6Zx67fIKiWcRjYYm86NTxY66oL2UfNZ4zh8huCIQRxkCgXBpYOh2ZzlyCAvUffC7S+CO9aWHp4rhgOgYBTp/EnnGI3IHu+OmRS1uCL20awjEEnPgoY4KivGTg49TkgkDmtWDiWZQOqWA8Z8uGsN2W5oz2ROqlGZVA6yv5wTLgnj35ED65rU1LgFuwU4Kxi1yD9zQuP3oROdA2rHtMi28ojXiEllZNeZ8vVPVzKBX+OSNzSLP8CzUYsoK3FtU3YwGpE/c2FQVcT32+imOpXmGTuZUC+OCrF+7rHIqLZ8cTDtGwIimioqeKeiLJZaxNTaKZozGoZJ16+pqgWU2r6z0uvme4SwGnZK5flFsPNm0uj3K0DSUDdituM5PAzn7Hg0K99/Q1DuaW9UWMQyrezizqD6kG04BJqVp5lRabq7y37+5sagYa9qjE6nSRLIESyc0fdOa6oKsr2mPuUQunlFSOTWZVda0xT52bR3LMJ++qaV7KLP96LiToZ8uuoAJjLY4Ftq6uvpIbzJbsPZ2Tl63rIJj6e++0GmC5QM9V5lfTIFhuaxD66L2Mi7ooh87ULprKXQb/e4uOVk0T0wYq2tZnkW3totHRoyjY3pbjF1cjhQNhOxTeVPWcczD7OrT/vSF/GTObI4yUQ+tGoxfpB/eU+ooY7e2Ci8cV/721UJRA090n0SdiuPJPNSlzlUMTFOUakDJ6dYW4ccH5bxi9SYMTFGbm4XJnDmVt1SdWlHFfXK19PxxpcrPrK/niyoss6RlEBE46yeTebOkYUcS76yJxQvwZU+XsFuw20Ha+6vacinCVRq42/WmuKHC214LE25ZNWx3ReaN/aNjiSLL0NuOjG9eWVUedok8e+fGOgxKcUvgmXePjp8cyvIcMzhR2H504q5NdXZbZv+ihqCmg0VjQTaeeXdgIlkSOHC9sq+zcBM61J2YSpcqI67aMu+6RWXH+5MsS9udvU+3m7bnm7NbkGiGxdl2WbTdD3XXscmb1lRXR9x22Sto8hQNOgbbAj7sdrGRgDSeLPrdfGXEs/3oxC3rahvKvRZL3bS2+o6NjA5qfvBujwbEPSemdhybuPvaeqOAr19eyUCjKNDycAzz5oFRjoXSb4aG4c1em4axnP0IlE/Bdj/fD49AICxMaIRcIifxkMsQeMYjQUkaOIdklf1dU9csiUmgQgbphce2rzVNPJYoDUzkb1xT/fgbvadGMgL/QY1lwNgEW//97k+V8AAyeVtnOw2IVexkpGWeM0NAFK2LiTYW3YNnbf9BlcEsfbgn8cCWpoYK38mhjCQyju3v2o7YqZHs8b6U7UUG7gjr2mPxjFyUdcdxeK6AEkyObij3/dHnVmOKCrj5N/aP/MczJzwuziWwsmJYFn5gS1NTlb865knn1c6BtNfFTaZK91zXwDDUH35rt4+DrCrGlMQz/eO5jUvKklklW9B4Doq7Tg1nH9jctHl5RSzo6h3JnhrJIhoNTxSuW1HRVhd0iSzcuewP2iNxM9WuZx0lKAi2Pn97m2Fgn5s/3JPoHsn6XJzLPk8gdmHp7UfGvnRXx699fIlmQgLrR/tHxlNFl8gmc+qajrLlLRGvxE8ki33jWcPE246M3XtdUzQA3aOaqn1v7B/VDah8haJb25M+kVWGpvI3rq7+lY8v+evv7z+QVboG05oB08iuwbSqWy5xzpqWsDTVEmVjXtowqaALLa/meqagsOLGVqF7yuyeMlrLmF+9zgNfFgb9wnrp1BS/qIL9920lu2STWlrFcQy6uZ3fPSAdGQULl48thfxbhQ+s3PcOaamSdUOL+PHl0utdKkLUL25yN4SZrkljcTnnFLzOCU5U7RHRLe1CT9wYSIKS58Y2HhowyXh5Ne9scMciodxHt5Vx+wa1I6M66GdCjItHJijEqI5yLuymDctxxqMqfEx7GXTCaQgzUS98NDxLtZWxAYl0jLmKA3cnT2x7wkCdvmFCh6Oe4eyLu4ZME+4oJ4cyL+8Z+uIdHQhZJQW24Tg6U9Aee+2UaVk8RfMc/cgrXRUR1+blFXlZh4QBhqvP2zuGDnXHJQE6wzn13diWACZzysmBdG3MwwnUksaQooEdqb3BtKpzOsPtTOVtB9OxeNF+EKSHksB1D2e++8LJ3/v0Skc9zzBobLxYE/M4FRsF2ZhMlTwSV1QMlqW7+9Mv7hr8lXuXOLY2qt0vzS2wO45NdA9lMIa+JzesquIYWlbBv9IutOVO9Kdf3T3krNs6hapneR07jzgSVFsCuPvE5JZVlXPVioJAIHy0sXsdTZfFne5rZLddFOjndg5+4Y52pxoeIce4FsoZUzll57Hxr35scXnYdWokMxejwJbJolKTVDaOKAGj6RzeGZ9dCGnPiFcci0pMs6jYaPdjmoshTMvc0chUMVNUl7VEjvQl3IhlaFhcfXn3cNdQBoSVFKWZVnnYJYnsd547Ad4ydqA8NyOwdxBKORkk2tMhUWCgftTeQZcA1Vlv7h/93G1tbXUBj8Q/+XZfpqAWStrJwXRbXQCWlK3ThwhjjmGO9CYeurlleKowNJn3e4STQ+ln3h345Y8vDnpElqEff6t3Kl3CmHrzwMgX7+oIeISptCwKpu2PjBgojT3vENn5rMGJYkVICvoEWTWe3zGo6SZizuSPEELP7xy6fkVVc7UfUdTARP6lXcPYomB9ICPnZX1ZU5il6RfsJug0Qk+/M7B+cXk0KDE03dmffvfQGHiPMmdN0/pGc+miFgtKYb+EsVVSzJKiizyTLepg+T8X+XbbQYhy8ej3bvZyDPRYLGrUL250GSbEuOV+5vdu8qRLlkeEsk7NwK+cVH0S9Zk10kjW7Jw07lgkBF30393rd/OgyP2tLe5UUeQ5FHEzhgnS/89f4/rEasnNoYJmPbRWun0RWPFEvXRWxqtquMUVnJsHj9G5Uv3QiFIN3FbGfu0u32DKCLjoCh8ta7i9nP36ff6ASO8e0Lom9U+tlkSO/t6uYoUPzPO+stGFKKqoWiKHvnanj2epnGLxDCpq+J5l4p1LRN3Av3St2/aqxwGR/uPbfAKLNLtim3B1Be6OF1i2qOVlg4F0BqwYYYwP9iRe2zs8Fi86blCWhd8+ONZSE2it9nfUh2TVONCdePLtvt5R6Jpm31HoiWTp1b3DksAsbgiVB6E98hv7Rp/a1geZcpZO5ZRsQadp2rSL7kuqsadzanlLhLOVgh11gUQWLCPTeVXTLZ+LzpXAxDiVU53YnaHRqZHsiYF0W23QkXxRFrW/M/7EW32L6gMUjUYmizRN1Vd4sW2VVSjpL+8e/tTNLd09CWfR4K2DYwGPsGVV5ZKGcK6oTWbkk/3pH7/em5d1QWCO9iX/6uEDn7q5ef2iMkUzExllz4mpbz9zIgXqfPAdSxdUl8DmSppjNWCYOJVXfR4+nVOnU1M0yuShYV5dmRek9nB0yVyYQCBcADu2o+NZ+euPHioqIKR+bvvg/pMJMKi1Fx4TGfn/fHdfQdYQol7dO3xyMNM1lAHzXIyf3tbfN5rrH8vZtTdzMhaakmtc2KuzsNB/trXJDKdDQ4qyEOYNV1GumVsXdciq6MbT7/TftK7mR691p7JKNOAyLGvb4bF8SRfB0RxsCn/3Mys03TzUnQh4xLkK2uEQIFSQ9W/+9JjbznxTGJJTUyk5lVP/5vsHUnb70mffHegbz8eCUq6gHjmVsiysmfiHr/XsPTmZzCoSD5+Osyt5Wc3bRV+TKXkC+kaJmma+smd4Il0KeoRUXj3Uk3De+pntA+OpksCy/RN5ngVhejqv/vl3940miufGkfZqTDwtP/ziyYqIK51X95+MBzzCc9sHDnTFHa05jeDM+aefHAFfSLgtFgYn806BmWFa33+pqyLsNkzraG8SLGhYum8s97ffP1AT8yAa9QxnxpJFhNAf/cfuvrGsR+KczPr+k/G/+O5egad7R7OmheNZhefADD5XhBWPObzN0Yiq8IE0XDXAtzHioTkaQXNQRFX66XIfTE+KKiTpUiXr0f3yVM7qnDR0E1cFYHWiOsAouqWZVJmPLvPCCrmiY8UWk4RdNMeiogqq94BER6AVErgxFjXs5umIB825OZxlgSq9LshE3GDNjhDOKdDhNeQG/z3FsB49UMrb49k3qP/GZl7goA8xTVEFFepGqmBfsKyDWsayqIBE8wyVUXDUQ1vYPgg0pOFlHc5AErhfXYG7hcEQfSJV+smbvSUVHM2nH6dwZ3/qWF/KcWQ3TWhQOpYoPfl2X0d9sH88r6jGzuNTL+4cFEWo6wAxHqbcLu7IqaSmm4Pj+YqwO1vUnt8+2DuSdbs4TbeGJwvP7hhwiWz3UAYhuAAd7Uv+5K1eHhrHgRntWwdHByZy2YKWLWo0op58p5+iqLFEwUlg0zQoBZ/a1t9cleobAxcwnqXHk8Xvv9S1tAnE9z1DmZvX1TjSmpF4oVjSX9s7LArM4VOJbAEaOMfT8k/f7suXtKGJQr6kT6RKJwfTR3uTosDQNJUr6s+82y8KDOgRVWMyrRzsju84NlFjt7ubSJae3T4gsMzJwTRny3FkzXhlz3AkIPWOZJ1kB0OjZE756dt9deXeXEmfsZ8nEAiEc3C8uvP2ZYdlaL+H33cyrmjjYT80U7S7OTJPvtMHBiAe4cip5K7jk343L9iimp7h7L7OeNAriND9Zy5GQ5tqIShmy3Bo0DQECvqvv9fWiFaMdL1S8lH03Hlf2wgcqBNXtkW/cveiF3YMDkzkJYGdSMm0XblEI3TXproNSyt+8FIXhcDaxjhtcPjBgUSmar4Ei8zTmXPHd9Lj4p58p59n6aBPGJosdA5lwn4hnVMFjnFLECoc7I7vOT7BsYzPzTvpf4yppir/DauqaBqNxPM6SGzAL2g8Vep6IxPxC/GMEvAIgi2GGRjP947m3CKXzqsUBV1Q3BL3+JunJIEF6dS5o4SiiOd2DAa8fFE23CLrFlnnzIkGwGQGIYpnmXcPj+/tnKIQpapmyCeANxoo79GhnsTbh8YcfxinmxXG+JU9wz4XZ1FUSTWCHoGiqEde7bYtaMB/k2OZ8WSxezjDMNCAqbbM214fivqlfZ1TU+kSzzJzGO5iTCWLELYy9ipUVoY1eA4SivD4tNEQ2LNQq2q4N7qVxw/JFKbuWiJWBxlZp2QdRCk0olLTG8M6lXMfzirwUrbSFvTip5eTQJyjGLiowbtQcwrU2pmUXDRZGtqd2h7toH0vqKZHoFtjbGOEffmkall4RTW3opq3LCqvwoBZu1tqogDWIDMa94IKagWOoTKy4wEKzVmTRdiG1KfOgNru/UfqqsERn5zzoJP1mX1XgMoYu7oUSsspuGhe0GvF2QAeRwi+RadfxGkS4azlzSjXZy67djukact2CHlPD2n2xk6xtpMacZZNnXXS052SqC/c2f6JG5pcIvflv3njeF/KJXCa3VCJpcF8xvnaO+VfdoslSE7MSCSdNWvdtGwTTEheODvoVAjNDN5xzJweDBS04NkjPK0Fgup+0pSJQCC8L07vTDABtJ28Z5ckOnU+jpstpOxm0rln/3MOQJalS+6yE2LL67p5tk7iPDBF8ZRVPHmnnK6nWYXCc5mhoGlUUvQlTZFv/OamV/YMf/OnR227FFD9UpiKBKS/+7UNx/rS//HksXRRPecONTcDsL2Mz2kkMuszsmVCoA+xG4ifbuntpJ0dJ0dnRF+5a9Gnbmqeysh/+fC+A10J8C2wZj0d5mZn3BRmXnNGJuo0+Z7ZO0geq0ZLdeCvfuWanqHMn3x7DwOf0vQYLnDmnG7I6tjNyKr5L//z2rBP+r1/3zmZgmh7ltGls7F9t7UVoc7bzX53Z4Q0Dd3B7t/c+KW7OqJ+6e8fPfjIqz1hn3iJcye4vep6ZW3NDRvbP7NG+oDtVhlEHRjVd/VrFT7m2iYh5oGmRVfinmthEPC806s/sX288+AR5z2cfamqr7txY+unVsN86bKAaTlH9cbNN7pVGqHrmvmWGKvpcybUMSwq4kbf2aN/4we7olTaQOx72cJ/hLhaMu4OEJVeqAHeObHnTD8I6IKBwPcX0+eeDY6bLNjfwkUKMyDVm3m63bEDgx2BM9t1TGacl7Dt0p1nwWzScblx1s5mB+7ONjSLTBNHg+Kv3780X9J3n5jEGNdX+G5cXa3ppt8r0Ghakj49IbFfwRmbdXr89jtR9OlVJmdyYbs3OHsHl8KZW9L04J2I/rQIBrwGQFt/ZhHZsYe3oHxqrj4cAoHwUeZM18nzsiBnHrCrfWaV15z9zzkYBEKMrmdqpUIZ8kxSJnfRpLtF06xGZWqNfDmiDVvhPPc9SjsHUt994eRX7l5UFnK9vm+4bzRXV+5d0hhe3BgaiRe//eyJTBEinisRjczUVZ374MxvCFsWBV2PZo96RlWEKGzBLrTXB2Ih17M7Bo72pkQOovbp7WDCRcEt7kxDQVjitp97VgHVWcOw42rDsqCzpgU3R5jUnTZYvsCZM/OQc7eyTxeOoU0DVkigf9aFN8YXfHdn2AghTbfaagOL60Ov7xvZdnjcLYKLGvVhgBC1tIKrDTACi7yi3Xl0QWXKTIuqCzEfXy5SFPKL6OwPhPAzcnUF7vYSGDvLOXf6QnW+HRV0KZqejl8sT08xDCNC2fT0K8x8sRkacQJrC+inX3nmEbhyWZjl7ZmC81cacRx8CjMbOwi8E8aDGNElcqvaojSFasugJ1QkIIW9IoWozoF0Og/rmDSDPCx0X5p5Becdp8dvX51mvzhUI/GMS4Da7Zl5xTmDt6zpixyiwDdg9u44R9IpCbCT8QQCgfA+zArOz1ULX+xP52/5gUGINg1DVMeWCU1va4yGIHaf5Q1pbwPZDlbjdFdpfJllcoi5EoE7lKhqGuj4fRK3piO2uj122/paDhZXqdF48aXdQ32j2YAXFB1XggteuM/5IMC6/py4duZ3+7+WhV/YOXiwO7H7xKSqWe5ZviuwenChp8xu4XT+MJzDksmrD7/YFc8qzoLuJZ05doMtjqWfeXfAa1s1wDLFee91esXgogfBSaWJPLPz2ESmoB3vSyWyitMunfow0EyKo0HUbligdXH6iC0UEAJ5PY2och+k/WQNdOpE8fLBuboCd8dP5lK2dL6l58frs18K0tAXuqvAN//s68E5j0Ai4sw/7EWACw3A7hgM71Jf7gPTXBN31AXtmnQwvvW5+Vd2D4/Giy57afKckTjv+B7jh/WESxv8BY/DBTcjEAiE+Q64yZhyqoHzjTHRLsxoFmZsg5lp9QdGFk2btMmZkx1KuhZfgajdwTCxJLKaZv7z40duvaa2OuapLfNMJEuHT6W2Hx7LFLWQT/xwu2W813vbwhXdsJ7e1q8blkfi3NJ0un3WJhd83nu+IwUp9nxJf/S1HhDBi9PZpUscLceil3cPQVcgFyTVLhCXX2JbX4F9Y//oCzuHJBH09x9iw0EaUbpFadDxd9qLaWFhm0RReWVaVkCi9jnh6grcFxyOiU1Ltd/n4lNZBdvLfxSFRZ4dmsjvOzk5t73cCAQC4SMPVDFRdH54bYBVjHCfHZc7SmTQB0KqGNNMoiU9ugrT1hWK2qddayyMaOSWuF3HJ5kTU89s63cyvoZjezbvr+4IUW7bkh8hkIDO1cvSNHLs/C/3FcFX3jZ6/4CHzimxFcEk5cNvEw7B7rw/E94D0Oou5PHPQ0jgPq+xUwj0K3uHOQ6tX1wecPMukZ1My28dGNjTOTEyBRaWpH8pgUAgXCaWobuyw+vEUtgd7TakjMEqFIU4XUClUCneXkw1mCaPaP1KB00g4WZoRYUmnppu0TSoEHluwVT9szTtGCvP7Y3I6cz6M7wojMeOvD/gAGiaZh2BKLnDEuYZJHCf7yCEjvQmSoo+kZR9bl4SmKmM/PaBsZ6RTNQvOeWtBAKBQLh0IChmVaUQQ4bEGoIpZQ1WBXU7BO4BJdmq6RLDFynrAk095xanDEkSGKgwck9XVc04j81/IK69AiP9mfPccxVnQ23bwvgECFcdJHCf71gWjgakdF79yZunnCskjaB2tjzksi0jP+zxEQgEwkLEYli+pJtsemLJGV8t2wYM0SbDyT+HqP2cOqL3qEoiEAgEBxK4LwDsBAx4VE17ZdkWkLMMtQgEAoFw+UzXpJ5lUDgtjSFdGgkfjIV4iz7HX2n24/N5wIi6uiCB+wIALOFp5PQxnfaU/HC9BggEAuEjAqYZ/eyrKSJRO+GDgqAbqGk3QF0ogG0/tHw6f8TQp8Y2r6bmFdi2HKXt47xASkLmBhK4LwyI/SKBQCBcCfCctkQlEADLSJVMgbX7LV6g6+O8w8KUxFFFjVJUA53j32/Cvogs0qAXIzVPwLZfjWXBj8Ah64qXkc8jSOBOIBAIBAKBMDcgRKulYu+koppeHkx3FgBORD6UNlKZHA1+qbP3pdAH++Kxe0JS8weeocby5lROD4mUqtp9b6irAhK4EwgEAoFAIMwBGGOGofO5QlBVXuzUPrmM9QgItBzU/AZR2/v0/qSu5jOGCe0FZu9LWFVf7NQeWMq6BRpK7Kh5AKJoCj9zzDjQm5UoVaYQWDJdHZDAnUAgEAgEAmFugJ6yulmIj+8f9NK0j6UXgFsQjahTcTM+NqEUCrMF4/a+GHnYFw9Fe2lkzJesO6YYmjoyqmemJilFoZ0iwKsDErgTCAQCgUAgzA2QqGbZxNikLxj4934lL5vM5XeB/XmDUHsEF8ZHNN3kOHZGzD69L6PjvoD/m71yUTFoNC887TCmWAYtDmuSkkhqFscw80iAf4VBbff+44c9BgKBQCAQCISPDhhjluNUE7Ql1EJAYCnK1C3L8Z5eAPuCKEpkKWzqpkVcZQgEAoFAIBAIPyuIpjVF4WlMz/90u6080RUKMSxNX0ArPk/3BVMajJlbAAsacwoJ3AkEAoFAIBDmFDtLbVHIohYGDEtR0OxxIe0Ly1LYWgAlBHMLCdwJBAKBQCAQ5hhbdb1gosr3VsHMz33B825EPw+uojpcAoFAIBAIBAJh4UICdwKBQCAQCAQCYQFAAncCgUAgEAgEAmEBQAJ3AoFAIBAIBAJhAUACdwKBQCAQCAQCYQFAAncCgUAgEAgEAmEBQAJ3AoFAIBAIBAJhAUACdwKBQCAQCAQCYQFAAncCgUAgEAgEAmEBQAJ3AoFAIBAIBAJhAUACdwKBQCAQCAQCYQFAAncCgUAgEAgEAmEBwH7YAyBcQRCiTv/fPAXb/8MUxvAbgUAgEAgEAuGikMD9o4xlYQvbcbEdIc9DnFkFjSiE5u3kgkAgEAgEAmFeQAL3jyYMDXGwpmNVN3XTMk0I4OcbCFEMQ3MMLXAMz8GATWv+jZJAIBAIBAJhfkAC948aNILkdbaoGSZuq/W31wWro56wT+S5eVfPoOlWMqeMxAsnB9NdQ1mWQX43jzE1HycZBAKBQCAQCB82JHD/SIEQpRmmaeLaMk9Dha+1zl8T85YFXH4Pz7HzLnDXDStb0Kpi7sqoqzrq6R/PjSdKDIM4liahO4FAIBAIBMI5kMD9IwXGFE0jn4e/c2Pd1tXVQxO5/V2Jl6eGkxlZ1SxqniHwdDgg1cU8q9oit6ypfePgyBNv9RVKOonaCQQCgUAgEM4Htd37jxd4mLAA4Rg6mVOWNoV+48Fl8bTcOZAZmconc0q2qMuqMQ/l4wyNJIH1u7mQT6yJeTvqA9Gg9C+PHznamwr7RN2cdzMNAoFAIBAIhA8RknH/iIAQShfUTUsrbl1fI6vm3pPxHUcmNN10SxzH0j6XQM87pQxlWZRpWamcNjxZ7BzIFBT9hlVVD97Q7HMN7zw+4XXxxCSSQCAQCAQCYQYSuH9E0A2rPOy6b3Oj18X/zQ/3lxTD6+IoioM8O8amZc3P/DWiKJ5jRJ6hKGrXsYkjpxJ/8NDq+zY39k/kMnmNZYhHJIFAIBAIBMI08y8NS7h8wEcG4c/d1q4Z5n88fVw3MM8ypoXBBHJ+Z63taQWM07RgzLqB/+Pp45phfu62dgphYu5OIBAIBAKBMAMJ3Bc4CKpRS7LxsU0NFWHpxV1DAxM5lkEss/A+WZahWQYNTORe3DVUEZY+tqmhJBs0NGf6sEdGIBAIBAKBMA9YeOEdYTY0Rama2VLjv2l19Y6jE0f7UkGvuECt0O3lASroFY/2pXYcnbhpdXVLjV/VTHKOEggEAoFAIJDAfcHjxOf3XN8wnipuPzrpd/PG/BSzXzKGafnd/Pajk+Op4j3XN8zsI4FAIBAIBMJVDgncF3q7JWtxQ6i12v/S7mHDtOahdczPAE1D+P7S7uHWav/ihpBmWETrTiAQCAQCgfCRCPSuYnTD2rKq6uRQuns44xLZj0ZyGmPKJbLdw5mTQ+ktq6p0Y2GvIRAIBAKBQCDMCSRwX8DoulUdddeWeV7fPyrwLIU/IqoS2AtMCTz7+v7R2jJPddSt6yR2JxAIBAKBcLVDAveFCo2QYeHrllcMTxXG4kWWoRdiQerFsDBmGXosXhyeKly3vMKwME3kMgQCgUAgEK5uSOC+QEEWxj4Xv6IlurdzEuOPoGUislPvezsnV7REfS7enpb87HuJwG4SXDJ5lmYZGlwmCYR5A2eflh/2KAgEAoEw37mqbxXo4j/zHJqmSorRWhugEOofyws8M7/7LP0sYIwFnukfy1MItdYGSorxM5feIgSdnvIlPZ1XJ9NyrqiByySJ3QnzhmRWyRRUsqpEIBAIhPeGpa5i3kM3Pc9voAhBWerSxtCpkYxhYo6d5+P92TFMfGoks7QxtP3I+M8c1ljwSWOvi2cYBBIj0zJNbBgWid0J8wFMUdGAhCmsaibpFkwgEAiE9+AqDdwZBnKwhmkhhM7PVCN75dow56loHCEIZ8MBsTLqfvfImGlhHl1GWaoTrVrWvNy3s0GIMi18ajRz7bLKcEDUDYu+nD11YGgka6bA0Z+6qbmpytdSE3jzwOi+zvibB0dDXgGS8QvgSBA+msAZblI8i/7kS2sSGeXvHznEMNTPcJITCAQC4SrhagzcEaKyBQ1jKuwTzfPiV4QgqJ1IlgJegZmXGVmEkKoaDRVeKN9MlNjLGSRClKIamKIkgV0QsTtLI9hHhq6Ouk8OOpaXlzFshChVN8tD0r3XNazpiPWP5WTFrIl5VrVGW2sDT73Tp6gGxzLzdIq20EAIpknnr1dhClvQF/dDGta8xEms0zTSdLO9PtJQ4Q14hVuvqXlx55BLYEyTHK33KFah8eXM/BfEhY5AIBAukasxcMeYKgtJyxojtWUe3cDnLk0jClv4YHd8OF7UTQvNV/v2mpinqOjZgsay9CXe5DGG25jfI1AUlStqPHepT/ywwJhiWTpb0IqKXhPzHO1NXe4rWBblFrkHb2i+b0vjjmMT33ziWFnI1Vjlu+e6hk/e2DwwkXv38DjojOb3cVgQIHsZR1bN8+MkhkYcRzMXWt26anGOkqbDhOaG1VUv7R7WdPOTW5t2HplI5hRRmBfqt3n4zbAwzhS1Szw4GGOeYy79Qjd/9nf+jIRAIMw3rsbA3bTwfZubPn1Ti2la04mvc4JFBk2m5b96eN/x/pTIz7vMNLatEqsi7mRGLSpGyCucv24wm5ldtCzsEtn1i2M8x7y4c+hnHgC8nr2a/x46E+dNP/jEgKFRtmgkM2pVxA2ZtstMtxumtbQxev+WxtFEsXs4ky1qJdUYnMxvPzL+B7+w+sEbmo6dShYUg2XQpb/w7N2/2D7ObDNP+HkoghD8H7h2nldDTNP24wuEuTp13+8tQM2ODas65l3bHvvnx49mi+oDW5o2LC1/els/Y28BjRk+3FMIUQjPtwgSMfbJ9L6jsre5zJKB+aOcI5E7gUC4CFdd4O7chq5dVvHq3uHdJyZdIjf7AonxdCbsM7e0rmqN7u2ccgmcdd4VFCHEMkjTobqRZZDT2hO04xgSQld6F0wLe1yc1813D2dBJ3PxN7RlP1RJNXiGZhjEc8y1SyvWdkRbagKyor+8e8Tr5kzzfQbM0Gh2EadlYUWDhXyBZ2TVYBmaYy6QSYVUIkUJZ+e6GBpcLC/vCGFbLZMsttb4PS5ON8zLCgF1w1rcGDrWnxocz29dVV1f7vv3J48NT+QRjYqKfvOa6va60J7OSYq56GvCR2zvvuNGaWFK0QzTxKLAKCqUEgr8BfJ5mmGZFpYE5oPsPgQodintzD9pevpku+DGF3xxRFG6aRkmFnmGumKABEszQ17hNx/sqCvzwVLVzBHF1JHe5Eu7h8YSxfcQaCEEEgjDhH3gWVq/whUmcLgu9A6grdJMioLT+woNAFGUqlsBD28YeNmiyC/fs7i1JlBX4ckV+KJq/M9PLvdI3HPvDqTyqktkeO6i2jCEKI5lDNNyDinMmBAyz/v9soc367myCuZLAjcvTKsQgq9VWVD68y+vK8oGej+PKdO0Al7hp2/3Pfl2f8AjmHaJ+lkvSFEcBwfQtLBjPltSdFFgPvjS0Plfxkv/RBBFGRbWdFPk2YUz2yUQCD8/rrrA3bSosoDEs/T/e+pY11CWZRE4OdgZUowxx9I8x5QUva02UBZy6aAGv9CLmFY6pwW8gqqbuaLhc/GYohS4yVHcJesvf2YsC3tEVhLYqXRJ4NiLeeNAxGZgkadryvyFkp7KqR4Xd+2yioEJ0HlvXFL+9sFxw8AzyeaLBUpFxVA0w0kwW5iSeKYi7KJpNJWW68q9+aJWUPRzgmmMqVhQQgjFM/LsZDZMIViIRi9jZyH6hz1d3hz2iGwyZ9AXD7LPwTRxZdS9uCH0nec6aQRR701ra7qH0o++2hP0iem8kswpa9qje2wj/IsdQ1k1Sorh3IQxhqrl6phHEtixeLE65jFMK55ROPashD3GOOwXXSI7Co2xztp9lqEvsXACITjyumF5XdzMPzXd9Hv480drxxwGx9Hnz2pMjAMewefiRxOFK+VYYqcpg17h3usby4KuoL0ENPNWpgltwmgafff5kxf7ajiFJYm8IgkMy9KTaTnoFa5cztE5XDzn5LXPwjBxRcRNUVQ8LV8R0yF7Lu338A9saQp6RURTyZzy4zd613XEogHplT1Di+pCW1ZWlgWkkURx2+GxdF7l2AvEzY4waTxZ9Lp4kYMiDdPCim7yHEPTcMwVwxQuf6qG7M9LMU0BXpOqLfNoupXIytwl6/GuKDA8O/a1Ly92nsUeFo0QxtjCEDHDsTr9p6BHgMzLhfpcOJNwOIASJwqsaVoMQ7fVBsaTJe0yswPn43zTWfrMBMD5dN73E4EdxLAuWh1zx9PyBZScBALhqufqCtyd+KAq6k7llGRWba72m5bFne574mQ3DdNSNT5f1H2ei8Y5NI1qyjzLmsK5ktY9lFU0AyHk1E3+bFmuy90FSWC9EpfIKixEsRd9R4ZBHfXB5S2RZFZ5efewohqSwOw+Mbnz6OTXvrpudXtsx9Fx0AJhSDhdLEzxubloQHSOBU2jTF5Z2hjyefgn3xm4c2Pd4Z74zuNTAntWjsqy8JqOqGHg57YPet3cTNjhkbjL9+qBqUUiq3glzsnXIvaSVrNphEqavmFJud8t7OucEnjm3cPjJdVY11H2xJt9FMYlxXhux0BbXcDn5oqyccHdx/aYI36JoeF3lqZTebWpyr+8OfztZ0/cur4mW9Qef6OXY5mz84J4eXO4Jub59rOdnOus3TdNfIn7D+GdG/wrS4rh/NPnhqisoOjnD5SmKY+Lc9LV52bvTNxU5VvZEv3uC53UlYFGqCDr1ywpv2tT/Z/+5x5ZN2ZHxLph3b6hduuqqlf3Dg9P5i+YQrZAs4bKQ1JjlU8SueN9Kdkuob5CIOQcrnM/Ckdbta4jhij01LZ+4XIEVJdxrDT9miVld2+qd0tc71j2t/91Rzqr/umX15SH3E+/PfBf+ZN//2sbH9jarGiGYVrPbh/gL/QNt+zrVWOFz57dwcoPQyPh9E4xDC3wzMUWZ94DOMnt59rLidQDW5pODKaffXdA4JgPvVzWmTYnMspvfePdunKvqsEInWkwXBZsOZZpG4XBR2nPXniOSeUUj8RZ56XbYQENUY0VvpJi6CY2TFwelj5/R/t/PHVsLFFizr6gXS5uEWYLsxeXGJoWXO//iSCENM1srnJ/8qbmbz11fCIlz/9KJAKB8HPm6grcp7GVjxBkm1Z52L2kKYQtCKcknu0ezuw5MSUJDEVdONXhGKjXlXn/6POrysNuTFE7jkz8w6MHKYw3LCnLFtRDp5KMnfecuaOYFkjS4X5qX4BZhrbX6LGzGbZdKS9r+BamvG6O55l0Tg35BONCWhfHMjIWku65rj6RVVuqfLuOTXYNZQYn8pGANJmRe0Yyd26oPdAdzxd1hoH7iku8gIzBsvAt62puWVtLQckuFfTy33r6RE2Zt6HC++b+sXUdMd2wdh6bcuIGJ9lMTSvLw4msYoHsgQFpiYkFjr5+ZeXB7kQio9h33On50nvvvl2filI5lecZr5u79GkRTSNVt1a2RLpG0nYtA2IY9M6hsYYKr9fNCxy9rDHyradPrGkva6wMHOqeYphzpRHg3qMbW1dXPXRLK88ypoWDXv6x13sTWWXLyqrHXu/ZsKQ8lVWf2dZPYeQk3THGNE3LqtlRH6qNeSwMe60ZEDZYlrV1dXXXULp/LH/+qUUjWFufPfhCSb/3+ob2uuDf//AgxljWzLs31V+zuOx3vrnDJcAaujPTMC1sGNjv5a9dWr6vKz6ZkhkaXo2G1CMkHS0Lw0neGOI5RtNB+TDncYBtuGksb44MjOe6hzMwsNk7iKlHXzvVWhPoqA/2DGVEnj3nhKURUnSzKuL+1fuXLGoIMjQaHC987Xt7E1mFY6HHrZP+dOY8jnzI0bzNqLzOedDRFDml2HjWU+wlI2yYlkfit6ys2HlsMpVTna+k84k4539jlY+zH7kSARPMJxVjVWvkaF/qlT1Dv/TxRRGfkEjLP3i5W+SZbFETOaao6I+9fioWlG5cXf3mgTFdN9DZnxpMDnWzLOT6r/9v69/98OAre4d8LiHsF9e2R989MpHJqzXl7mVN4bcOjCma4ez+jL+Ks7P2wZk+42a0cKYFRvINFb4ljaFX9w0LHHP3tfWKblIIO+JA5wA6hx0cdW0N/GznlvNffG6BOQmNNMM83p9SNJNlkNfFw2KUbPAczDdyBc3JanMsXZR1l8g5l+LzZ2iaYYV9wn/90dZ//vGR53cOMQxqrPTdcU3tY6+fGk+UnIp/+EJb0180e78gvndewekIcc455iyDsBxz3fLynuFM31je7oaLdcOqjHjWtkffODBaUg0ahnTmQDmqfTiGGLMssmRcFpQ+dWPLo6/0jMSLbpFzSh2u0CElEAgLjqsxcHfW8XmeyRX1X/54Q2uNX9PhekzTaN2imM/Fv3N4jLl4+3HDxPde39hYGXh2x0DUL959bf2R3sS3nj7xh1+o7B3JPL9jqL7CW1SMXFGD1IvEuQR2Ilnye3jIWllWPCO7BJbnmKl0EWTQPBv0CpdxSbZXfb0SV5CNS3lWecj9/Zd6HtjS+IkbmvZ3x0M+4dplFbpuVkbcK1oiD97QFE/LksBMpeWdxyd5FsLp2a9qYVwZcYd8wv6uKZpG6TyXyqmLG0IeF19SjR+93jORhJyQopu5gkbTiOdo08SSyHhENpUDOY2trqZFnk3mlE1LyzsH0vmiFvQL8YxsmBbH0gHb5ea9sTAuyIZX4qbF5pecn/O7+Vf2DAscSPw13eoezOim5UxRQj6heyQzNJmviLgOdF24HMyyYFG+rsy749iEhXEyz40niwGP4HfzpkX96LUe3bBYmlYNayqjUJgSBdYwMctQbpHlOHoqI6saSDKCXnEkXlq/uCxX0PacmKqMuM8xLNJNSJrOXqA3LassJDVV+k6PBMeCUmttwLIshkbpglpSDISokA/s7S0Lf+za+u1HJxIZuSrizhTUgmwwDAr5BBohjqVFgb1C3aYQhUwT+9x8R13g8Td7pzKyR4JQY2YDBqG+sey2I+MekTtL+z5zkGF6w9y0rnrzisrtRyeyReWWNbWfurHlHx8/wrEonVNlFdZDgl6B55h0XnViR5qGvXPO1UxBNU2YITsPZotaUdbtT1/gONp+CswPLQvGCQMQ8eYVVW8fGs/k1UhATGYVRYO3sA8XqNt5hrlyy2VeF9dU6X9l7/BT2/ruub4hFpJ6hrN7TkzJJa2y3NteG4gGxe89fxLR6K++eo3AM6pmXHA0zdX+juZIc7Xv7UNMoaRVR913bap/Ydfg8FRhZVvktvW1j77aIwmMYcLhUnXTJbI+Nx/PyJpuMjQNO2uHm7ZrE7QljvilogJXlZvWVj/1Tp/OW//25LHekaxLYFXdTOdUp2wj4BUwxqmcaov1oR7A5+KdcDmZU2TV4Bg64BUut5T8EuE42Nlb19eubo+OJ4pPvt2nm/hj19X3jGSPnkp85ubWzsG0YeK+sez9NzS9snvYsKwL6l4wphqr/ItbIi01fmYPElh6YDz3948cTGblkmoUVd0w4HRyCaxsCwU13ZQEOIBOwA2npWayNHIu7JmC5iQgVN2MBqS7NtZ/84mj44lifbnPokCXpRnmzetqnt8xqOqGS+Cm0iXdgKtf0CtqupGX9YCHF3kmlVPzJb1/Iv+X/70/lVdBNpYqqQYolwK2eIxAIBCuxsDdSfWqmhnxS8uawsf6kpphMjTKl/RNSytuXFP98p5hJ7i/SNIdXbus4q2DY3/58P76cm91maeh0tdU7V/WGA64+JWtoEuJBaRVrRGE0GSqlMqrm5aVD00W8iWN55iVLZFUXs2XtOuWV/Isncop/RN5/nKU8bDQL/GpnMKdlyQ+JzWVLWjjidKB7nhLtf/+zQ1hv+h18zRCt66vYRkmmQWFd0nRQdiAoEvR0VNJ+nQifOZ1NN062B3/f08dFwUGUeCqvmVVpWaY+ZJ+cjCdyWuabvk9/JLGkGFYBVkXOGZ4qlBSTZahV7dFq6Lu0UQxkZVXt0WrY55NS8sTGbmkmStbI5LAFmV9YDz/3jElhOCMs+RtR12XhmmBOpyF+3EeMrUINVf7V7VFGITSedXn4ihEuUR2KlOqjrrfI+ev6eaJgfQ/PnYY0ZBQHJoofO62tpJqyIpxrD9l58INt8QtaaxACFYGPBJ3aiRTUuFmv6olUl/hm0yVRqaKa9qiTZU+eVnFiYFUKqeyp2XxhmFFg1JrjX/fybhhnlnnQQhOyGROcZLFDI2Ksm4Lr+kSuPj7YkHJtPDgRD5XUjcsLm+qCmxaWk4jkBXVVXjLQy5VMwcn8ylFsyysgYyGuhIgBNaiq9qiZSEpni7VVXgl/iwxDEMjr5s3TKuh3Fcd82SL2ow47XTy2KqMuO/cWL/7xNQ3fnw4k1c4mrn3+sbvv9KdyatttYGwXzJMq388V5T1jvoQQ1M8B07nfWM5J4pqrQ1CdQoLa1mnRrKNlXBwSooxAueh0VEfpBESBYZjmMlUKZlT1i8uq6/wbV5ZtfPoxHiyuKghCLp8O9rLFjXDsK6cb6VFgX5D1c2gR7hhVTVD00XZcIncmg5IGRzsiZdUwyfxNWWeqbSczCklWb/AtwPDdGh5c2RwOFNb5vW5+KKsb1xa3lzl37ikPODJrG2PNVf5t6ys6hnOeN0cxzA+N5fMqcOT+eUtER8UeVunRrMQ0xtWY5UvFpAMC46nD3PXLC5rrPTdvLbmrcNjO45OmHabYbfEblxaznF0KqsMTRYYBi1uCE1PhChqJF7IlXQKU4vrQyGfUFKNgfG8qkNGfM7POqe0t6nS95W7O/Z1Tr2wc7Cj0vfx6xveOjh2qDt+87oaj4sLesUn3ur9+PWNbx8cs5QLf7kRRa1ojgwMZ6si7pBXKCr6RKq0+8RUtqA2VvolgRF4qFtN5dSAh0cIeV2QsxhLQLaFRqitNhDyiapuDk0WirLeWuPnOcZZWQ37xLaawLpFZYmMkimqGKOAR1i/KFZf4b15bc2re4csjNe0x1wiV1L0/vFcLCQtCYSGJgu5ktZc5XeL3OBU/u3DYwVZZ2h6dUfUI3K5kjYwnp/jQ0kgEBYmV2PgTmFYsNZ0a1V7dCSe/9cnjtmLvBDx5Ap6e13AcQCAW86FqgBZe612JJ5nEMoU1G8/fSJT1L5wR3s0KAU8wlfvWfw33z9w+4a6z9zcQiP00u7BR17t+d9fWPPNnx59addQQ0D6/c+uevjlrqlU6WtfWSeJzPH+9B//525Vu0Am8iJjh5DOJUHIC1HLxbdEiJIVYypdWtwQHJzMbzs2UZINSD45b+SYpFAUTaGiqm9aUvGZm5r/eCBtq43PejuOhZRqOq+6dUh464Zlq1yQwNFfuXPRtiMTz27vv2Np7edvb0vATT0f8ol//8ghVTNry7y/+cDSJY2hp9/tf+S1ni/c3iFwzCduaOkfzx/vT/7PTy4Peniw3fz+/kRGfY+STUeNCgvfEnvBTrcX3HfLwiLP8QzNsbAIEHALn7m1ZVVbdPexyZGpQntdIJVTwn6Rsk39sa3yxxdx3qQonMorDI0YmlY1mOM5XYa+eHtHqiD/02NHNi2t+MPPrdJM62B3ornS/6f/tUdRIfH2vz65YtPS8neOjP/pd/b84t2Ly4Ku6ms848nSvzxxJBqAYJQGNQ6sfnzl7kWdgztgMjarEpEBzyJbXA/nHeT/OBZCXoTQL9zWunllpWngf/7Jkb0npz5zU4tmmL/y8SVBr/i9l07+wm1tW1dXZXPa//3x4df2jtgDvlLZOmxHopuWVsBEpS26oiV6zlvRCAx8VrdH68p8w/HCU+/0n/1JwbcpGpBqY56//u/9Tjnv0+8OtNQGyoOSppu/8vGlK1sjum5+/bFDr+4Z+dztbRVhl1fihiYLf/gfu+yiSfyZm1vqK3wekRmZKn3t4X2fv6N98/LKiXTpm08cffPA6OfvaI/4xKBXKA+5fvzGqaff7X/whma3yP7qxxcLPPPoy12/+Yll7bVBbFl/84ODr+0bOa16uALHCtTnKJPXDnTHr1lcvnF5OcfQU2l5SWP4V+9fvKgu+JcP739m20DXYPbW9bUUxif6U7mi5vfw51TO2MuDdGttYCpTaq4OiDwT8Aj3Xd9kmNav37f0QHdiRSt8Cn/6xTV//O09m1dWNFT4F9cHv/9qz2Ovdf/uZ1bWlXlUzfjz7+070JXwStyX7urYtLRc162//sGBeEb+/O3tNKL+16dXdA5lfvfTK7YfHf/Oc53Xr6z8nw8ulyTmQFfiL763L53XvvKxDpgM24Hmd54/8eM3esuCrt94YOnSxlAyp/71Dw7s74pz7OW1S7sUTMvyubhn3x3YtKxi1/GJkmLcvLZ6MiVXhF1Rv+tgT6Kx0ldb7t11fEJWoUjgtGvruR+EHXwH45lSQ6U/4hcnU6U17bE//Nzq//Uv7966rmZNRyzg4QfG828dGrt/S6NhWG21gUOnEv/wyOHxZLEy4v7le5esbI1k8tq//vTIq3tHHryhqa0uxNLgrYQx6F4+fVNL0CN+4/FDFIVaa/xfvnMRjdBvf3rFgZ44w6A/+vyaWFCaSst/8u1dUb/r9x5a+Q8/OvjKnpEv3wUXyYdf7v6zL6/9rW9ssyzrjz63uizoGokX/8939wxNFs+pgycQCFch72ep9dECNIgmThdAGgMKDYyzBejl4VzZEQUxBMfRQa/gdXGZvJa15S5nvYIt6EQUtbIl0lrrn0zJ249NdA1l4mm5qOi5ktYzkgn7xQe2NIJtomFuXlkZDUjZora0MUxRVDQgttQEiiXjwRtaKIo6OZC5ZlHZnRvqQfh4yUoGZK/m205t76MbsSxckPWVLZGe4exre0fePTz+1sHRN/aNvnkAfl7fN/LWgbG3D43tOj75n8+eYFkm5BPOT8w6zUfjaSWRBRsW3bDnGBgzDB2A1XaqIuy+9/oGRTNUzVjbURb0CRxLK5rRUuNziWxJNTYsKW+s8PWMZDCmxlPFZE65e1O9382fHMzUV0AvJON0SdmFwbBIIqvgyXCp0xu7jEE3rN7xrB304KBPKAtJz7878PhbvT43ly/p33mucyxRPNAVn0pDUH4xu2qnYHEyJU+l5Km0rGimk+VFCAW9vMSzHon73G1tLMskMqAFKo+4wClSM2pinoqIO5lTV7dF13WUdQ6mNcOMZ+TJNDSCdd4MPDpZWuAYj8TxHAOS7ll76BRUxHPKVFqeTMklGfTKRVnfuqZq66rqeFrBFPWFO9olgT01mkEIDU0WTg6l17bH7rm2IZFRQj7xnmsbwj7hggKVuUI3rFvW19yyvkbRzGuWlG1YWnbNkrN+1i2ObV5ZWRX1sCz65Nbm9rqgfQqdZTAKVk6qPpEugUSYpruG0l9/9FDvaO66FVW3ra8ZTxRFgblrQ300ILoFdkVLxCWyPSMZ5zUQQn43v7wp7HXznYOppQ3h29fXJnNKQ4X31vU1AscEPcKKlgh8ZDR1zeLykgqZeNPCQ5OFvpHsvdc3Xru0cjxZ4jn2Uzc1i/yVbaMLvRQE9qXdQ+A8yLHff7E7nlGaa3z5krbnxOQ1i8owprYdGauKuttqg09v6xcuNB6MKZ6jA27+YFdCEhivm88WteE4uAb1j+dPDqWnUiVMUd3Dmam07HMLa9pjGFEjk4VPbG1Z3RoZjRf9HuHTN7bIqrFpWcUta2smkqDqfuiWVo6h+8dyGFN9o/DFqYy4BR50fZ+/vd0lseOJ0rpFUFZbKGlhn7iuI5aXdY5jbllbW5D1NYtiq9qiR3pT5WHp7mvr3SJYtcz5iedI4Iam8pm8eqw/ZQ/S886hMb9bqIi49nVObVpaEU/LI/EizzEX8x6FfARc5/mD3QmBY9wSiLgkga0ISyxD8zwsFXrd/KnRLM/C75UR91Ra3ri0fFVbGGO8dlHs+uVwzgR9wt0b62MBSRLYZU2hcEDsHEj3jWcpihpLFHvHsqB/o2FJangyjzHVO5q1LHz/lqamap+TPrhpTc2+rqmAV9i4tKI85FrTHt3XBUVWVRE3zzI3rqmJBaTjfaklDaGPX99YUiEHP8cHlEAgLDSuoow7xNwYB7z8jWuqF9UHf++hlUGfUFfu+d+fF5w0tqKZLTW+iF/6nU+vXNMRTWXVm9dWn79AiTHec2LqoVtbv1zQ9nZOnRxKH+pJvHtk/N7NDZPJ0nPbB8tC0qnR7JPv9BcU/c++uLYq4t59fHJte5RjaI/EaTrI3Nd2xF7aBcn4//Wp5bbbN0wGLh2OoUuKeSm73DeWu25ZxQ9eOZUrahbGnJOBtld7He9ty8Icx4zGJx+8oaksJE2kZDRrgdtRMrRU+x7c2uSYpm0/OgGKDvuvJcUoqUZlxFURdn3r2ROTydJnbm7lONqCGk1UUvRntw+IAvNLH1tcHnI9u6N/49LyNw+Odg9lf/3+Jcf7Ut/48ZFfuK2NfV9DZhvdsFzi5SmPdRMOEbLd2eorvBamnni7P5VXIgFR08ztRyYaKn2qbr17eIy3M9kXPICGiUM+8aFbWu2iT/qdQ2OG7dEGCxqqUZSNkF9cVB989PVTu49P/MJt7U3VPli1AMN186Vdg+NJ+Y8+v3pZU/jhl07edW3dwZOJnccn3CCyh+A1V9QmU6WpjJzJa5PJUiInh7wiz02n1XUD15Z7vnRnO6Kg0Hbd4hhlT6JWtUZV3fz3J49XRFy/dt+S2jLvy3uHr1tR9fS2/n0np/7nJ1d0DqT/4r/3bVxS/tnb2qJ23vrsctE55vZrartHMs9s66+EaOMCJhg0jVI5RTOsuzfWX7us/EBX3C5RdbaDGWAsKI4mihhjgWcYBummtePYhGmC7enLe4b+7afHtqyq+szNLX63oGjm4ET+By93HexOsHYQ41g5DU0Wfvhq197OqS/fteh4f/qvHt53w+qqezY1VITdimYkc+p/PH28udr3sU2NQa/46r6RpU3hZ7YN7O+Kf+62thd2Dv7XcyduWlv76RubwAbxsr1YLgNswax7eLIwEi++e2QcakB5ZlFd8JGXexCi/tenlvs9/IGeeGibuGFJef9Y3u+FdDs655w0rKb6AEVRT7/bX1fhba0JnOjvf+fQaHtd4KltfQe6EwGP0FTl/8Er3QMTecvEuaL2b08e3X9yqqO+7Sdv9f7g5e5P3tiyZUWlxDHXLC4bmiz86xNHlzSGv3xXh6yaz+0Y+OV7l/zo9VOFkqYZZknRm6v8DeW+77/cdaQ38dufWrF2UZnx+FFNt9J57V9+cvSmtTXXLyt3iWxrdWA0XvzLh/d/7Lq6ipCbY2jj8m1tLhELJvMwibWPCDUSLxqW5ZLYrqEMx9I7j01Czf1FUiHOAWyuCjI0/cy7/VVRd2Olb+exCdPCeRnaT6ialSupP36t54XdQ2vbYxxDP7d94PCpxK8/sGzzisq3DoxtXVl1rD/5zSePbVpS/sANTRVhV0k1xpLFR17t2XFkIhIQb1pd/fr+kTf2jzhT9MlU6YVdQ79a6Xvs9Z5cSedZ+vsvdT337sAv3bt4eXMkkVVe2j20tDH8sWvrGZp+de9Ic7WvUNQQoq5fXrn7xOQ/PHLol+5dAmVX864ZFoFA+BC4qgJ3pKjGmrbYXRvrUjlldXvUueUvagid3gCiw3xRW9sRLalGVdT1C7e1/cX39s30yHRgGPTUu/0rWsPrOmI3r615efdQIiMPTuQV1UxmldGpgsgz33+pq3cspxtWtqiFfCJUKVU08RwNvyeLRUV33jpdUB9+qUvVTcn2ZLzUHYGwkLIw2BG8x2ZOVvj4QObe6xuXNAaTWYVjaFUHv0vHcwNj7HXxdoEaOA8GvPz5LwhaDs1qrPL/8r2LWYYuyHrPSHbGc81pTlQWdvWP5989ND6aKNaUee7eVG8XpLInBtKv7Bn2e4Uv39nBc/TAeMEwraHJQraggkkChsD3+Z0DjF09+X5L6sjCFo1AZH+pRwkhwzCrY14ordOsla2RREYpqXrIJ+i6ZVh4WXP45jU1Hjf3H08dA2OIC02dbCGHFQu6/scnVjgiHbB5nrX7CFFVUfdEWn5lz9CBrrjPLfzh51ZZFlRbDk0WnnynL1vQf+3+JW6J7R/Py4o5miiOJ0oBN287N1plQZejEhEFpqnaHy6IimrKqsEwFG1n+uvKvF+5q8O5/XMc3TuakwTW7+L2nJh86+CoKDBbV1UtaQy9smcEY9w9nLYs3Frt33V8sm8s5/fwbpH1uLgr1/rXSf3GAtI//vjwsb7U/q54saSfv3iCYcIsFGRd06x7rq+3F1jOvAJDo0hALMqmrMJEy7GOCfsETbf2n5w81p8cnioMjOUEjqEQ5ZbYw6cSj752KuQRHKmYhUGBfaw/+YOXusvCrlVtkRd3DvWMZCWR/dLtHdUxD6JQ/3juqW19bbXB26+pa6v2dw5mNMPqGckomgGH8cTESLw4ligUVXDevLI49akS75VAM+0SWUSBn0muqHs9YJrEMnSmoPaN5pY0hnxuHowOz3kB24RnTXuMRmh/V3wyWdq4uOwnb/aOJ2G94tRodiolJ+zK766hTEkxBJ7pGc489vopt8S9tGuIpiEZPJ4s5kp6OCDWlXufeXfgjQOjQ5OFtppAtqgOTRZ00zoJC0QWy4BMbkljaGSq8JM3eydSpXXtsaXNEadU5vhA+sWdQxLPrGmLVIbdCFN5WdMN8/ntQ5GA4KyrXKHVCycmd5RjlkXdsKpK5BnTtHTTmkrLo4mCR3qPVl+Qo1ndFuVZen9XYixRXL8o9tjrPTCHtG3gJYHpGYbMy2iyeO2yirysP/Vuf9dAuqMhdP/mppBPaKsNfPPJY6/tHU5n1U/c2Ox18zzHnBrJ/eClLo4Fz0dnJjmZKoX9IswEDKjQgE9kOFNU9Bd2DpVkfTwpdw1lrlte2VDhe37H4KrWyH2bG4/2p6AmlQEzJbg9gzWWWQCXoR6RZy5o/EUgEK42rqLAnUZIVsC0rncs+7c/OMjb7QDtnh0zm9jNFDFkoAslbUlT6O5NDSLPKpo601bJWagdSxT/7L/23b2p/s4NdVtWVvaMZL7x2BFw+KIo2vYurI55fuOBpX63UBZ0sSxKZECM4fcIixtDR3oTySyIH+7eVFcWkn76dn/PSFa4Mv1NGIbOF7VMXv3MTS3vHpuI+sSe0ezBroTPzWm22cuq9qhX4lTdLAtK0YAEZWfnWKfZMhVVMyZS0ISlIGuyath90J2jAenS2phnPAFxAEIokVGdZigsgzIFragaYduqApzO7Sc5PobjidKK5vAffm7VK3tH9p2csnXkc73vkPI3VNWMBMSKiKu9LvhvPz1uC/QRpFQx9Ykbm9cvKjMM69U9w50DaagWvYAoweljZU2mZccPLl/SZqtZLEw1VflTOWU8WRR4ZjxVspu/YJZGBVlL5lS3yOaL2vQO2nl6eB0ExYXZovGFOxrv3FhXUg2/m//zL6/VDOs/nz7x7uExjgUfaIZGUxnlrQMj9oKDuaw5amt+xFjI9dKuQY5F+ZJWUvTKiNspdsAYrOI9Lm7D0rLqMo8fXC8ZAdoMXcH+6QwN0zkKU3/1S9e8sHPwpZ1DzorBOdWEX7yjfSxZmkyWzpdiwVEt6hIUjzrzt+mnMzQ9lizdur720ze1xIKS3foXpkolxTANi2bg23rmq60amgFqB5fAbVxaXhVzuwRWklivi9UNiOfA+iOvYoryunl82uyVZ5nBicK919d/6saW2jIvtAi9QofpbK2d3yO01wUXN4b//L/2grOhbn71nkUnh9LH+1MFWSsPuX79gaXRgBjwCsmszJxd4umsAjVXBwSOqSvz2nWi4RnxlVPEMiMicp4ymZYZmuYYenAi9+DW5oduaW2rCVrYcolcLCgNTOQYGr6t//STI1Npub7C51QBgYbQdimtjLpVHbISksCc6E9ft7IyFgQvlGRGdonsSBzqNX0ubipberCx6c+/tPbFPcNvHhhx8gtXqoWW81+nc5yFH7qlpX88p+lWRdjl9/LRgHhB01UHGqb0VnO1X+CZujIPy9CLG8As1ZkjOW34JtLgLcPS0EQpnpZN07kp6CwDtrksXAl1gWVkzUhmFbcLJG7K6TPQyS3Yh+/0R+b8024EYZp4NF64b0tTY7m3tTaYysN1tX88F8/I6zrKvv3siXwJAnc48hY+2BN/4IZmr4t/affQmwdGRejmSwJ3AuFqh73a2qZ6XFzPcPZ4f4rnQHcBUdSs5dzpuMr2+iip5v2bm1wim8orM1aBThiXzqvpPDjQHe1N/sFnV7XXBqGfvF3ISFOoIuL69E3NG5dUJPMqz0I6uW8iN5kutdcFWmuCb+wfLsj6o691/9I9i++9vtHvEb77fOexvpQACpNL2gtsW6rToDB5nycwNIz2jQOjn9jatHVlFcug5hr/RFJO5RSMqds31K1rj0GnG+j0Ke3vimcLGnv2+jJY9fEge33k1R5JZA3TSmQU2xHlzFuzLPicsHZr9JJi1786zzVBkMOxoDVHti+Kk0MSOOb5HYMhr3DD6qqQX6Qoat/JqfdrzYhpBMfHXiu+ZNUHptJ5tb0+WFPmUVTzcE9C4tmptCxy7HUrKivDrm89dfzGNdVr2mMDY3lFh5GfEyQ5d/F4uvTNnx6zLapR72hubUds9u5zDLhhUhRyS3xRgVmN87hdFwe6CN32iWPs/Yd+inYQ71hi8xzt9/AWhvs9y6I85Dqnq4OhDJpBY3HIdGKMS6pBYXppc9AlsC7oIKtKAqsZ2LC7cUGTdtt7R+Qh/PUFXWGvxHO0bsA5dWlapJ8d3W76Ux1zszQSRdYtnmt2JPK4psxbX+F968CY3aj43EA2npF9Lk4UGKoAZ4isGVkFWuRuXlH5ix9bJPHQCsCemkx/rBxLMzRtWafVYnYdOaiT7YinIuwO+0R7sci0jQ6RYU43kHdWz5xTVBSgAOOOa+oeuqUtaPejNWdfC64MTguz26+pjYWk8WTp+hUVI/HCo6/2/NK9i5uqfH//yCHDtD55Y7OqmePJ0m3ra/79qWMR21Tn9PGC65Uo0G6Rbazy/vmX17XU+OFEsvccU+C3YxdKwA4KdhdVRzPmEllZNT9+Xf2nbmoBO1qWHokXWAZKzDUdTj+aRicG0rxtzmO7Lp45aVwCa5/L8EuqoAos45FAwGPHqXB66yb2uvm3DoyuX1R27YrKhiow2N1+ZMKphL9CkaadZJn+/Zl3B6qibqfaQVYhO3O4J2V7NJ33/va8WuAZt8TWlcMBbKgE236ePTNno+15MtSC26dTQdY4FlSOTusPBqxjLMqeJNO2c5dot8FzbOyd1sj2l3H6m+5g294j1j68d2yoe2BLIw9pdTqZhYyAppnjiRJD00OTBbvphD1SRD2/c3B5c/TW9bWwcISoV/aMeK/kAhqBQFgQXF2Bu913w5QVozzkshudXnQzO2fMiDx7jqOZhbHfLSxtCveP5XpGswe64zevrRF4xr63YRNT0EJycfmKluhT2/p7RrOfvqnZJXKDE4XJlHzN4vKgV0jlICf92r4RhNCmpeU3rKoaHK/eezIuXU5VnG47oF/aLqMD3fFIQAy4hYZKb325l7Zl64sbgresqekZyYxMFXmOHpwsvH1o1HaLuUAnxWRG2X503C3xznPPqSwcSxS3rq6ibMV2RViaKW91woeZ24zzsGbXth7oTjA0GpjMbVxSceu6ml3HJ953dziWdiLgS8RxBz85lL5zQ11RMV7cNVSQNUnglldFljWFN6+oLA+7LAukF9ctr2Bp1DmU3nVs0mkrc/buo7ysv31w1HGVAR3LLAEATVHDU4X7wm6fmz/Sm1q3KDbzRCfjOOMH4kQZugFSJWd9X+DoHccmRuOFWFC6e1PDE2/1TqVKfWO5GQNsJ7s8NFnAGBdlA5xtEC1rOmToPQJ0fNRBLgVGFnaXGVkzFA0Cjl3HJzr7Mx4X6/PwyawCraCoKwXGECAOTxX+6cdHDnTFUzmlIDtOOGeOIY2ox9+EmmCaQpA1PPeTgmKJsqAk8IyimpQF/cXWLYJy3tvW12KMH36pK+wT77+h2TmYdrP6c3vEOkfYKcPd1zm1t3Mq4BG8Hm5wIi/ABMZ0DF6dI++cmapm6oZ12/oakaO//3JXddSzaVn5FTtOM6OEbkcbl5a/dWB0X1f8vs2Nbx2EMvEv3NHeXhtM5RSvm9+yqvJffnJU083P397+nec6Z++pHVNatTGPz8Md6UlxHH1qNFcRkhoqfPY8Gco5ZvYUPEntD56hoayFoqg7N9bruvnfb5xa3BCsLfMZpqVoJs/SoKjhmDXt0b7RnD0Nw5p25pRRVCjINi1cVAyvm1N1q6hMm1Tahvpw5HmO7hrKgO/7aO765ZWfvrn1QFe8qJiXdpX6WRDAfhE+SJfAPPZ6z1c+toii8NKmcDqn+t2CR+IuuI7nHMDqmCfoEQ6fSrAs3TeWr4q4GiuhNGX6I7LX6+z1WEiRuCVO1Yw8SOQg/jahUQNtmFa+pEcNyyNxujGtPXee4ngHKZo5W+JvSxPhPOc55oEtTVPp0qt7Rzpqg2UhF8w5WVBRmpbVWhvY0znlXDNphI70pf79qWOnxmq2rqq6e2P9K3tg8Y1AIFzlXHUl6k5TSUU33/tH1uBOf0544Ny9IgHxdz6zorUmwLNQVJcvgS+NYSdKebsus6XSN5Ys/tX39z+zra8EKhG6JOvpvLq6LaLYvr8ukW2vDew8NvFn397TP54vC7nMmTTLJYChfMqUBLuK7j2f5AiITRO/sGPov17onEzJPcO53rGcW2RvvaY2X1K//Wzno6/1/PDV7odf6hqeLF6sUwnL0j4X73VxTpJp1gGB9dyB8Xxzlb++whsNSusXlama6bzOuXaadj2ZCAolqqXG3z+e+/qjhw92J2JByQlT31MWTEkCo4LV2iUeJDtZztH7OuMVYTeiqJd2DdI0kgTmVz6+5DceWNpc7fe4uN99aEVTlb8y7P7c7W13bajzuLhzCgFnjqHfzTs/M5qE6aHRkIMvC0rLW8JeF3fTmurZDjnn92sU7aY3M/OKE33pH79+as+JeCavPrt98MXdwxnoY3XmuNH2AgX82FWbLEunc2o8LS9pCHEM2B/53dzIZMHZX5cIKx7pvNo9nPnhq92PvXbqld3DqawC47liSTr4htjZx13HJylElQWloEcIes/8hLxCwCMc60u+vm/UjnjwBURNmolosOcTecaw8PpFZb/30MqWKn9F2P3k2/3/8pOjezqnnDWK92jA5dSo5ArayaHMwy91P/5m7yt7hrIFDcRR03HV9GYWhtBWEsDMRxCY7UcmvvHjI/u64nbb3yuIfQGxfC4IK59+d+BEf8r2CKeroh63yHUNp5ur/V6JK8rGZKp0ajRr94QSZ5cE2AJ3o7UmUBFyf/3RQ3/w/3b++X/tLanmhsVlqg7fOwHURNMLC8LprDn00LUbPzEMen3f6D8/fuRYXwpmpCV9KqPUV3h56ATEP3hDk9PPC7qQOs+1q8yHpwqSwERDLoSopQ3hXFGbSstn+ivZ33PLolpqAqmc+rc/OPDD17qaKn0eibMva1fqYGomSMnhYqhbIR/4uuqG1V4X7J/IDUyATkazm0Od9xFASN1U5auJeb7x2OHf/387/+y/9uSK2oYl5boBTdBmjtj052VaZUHJ7xFoBkXsOu+ioquaGQvC0Qj5hGhQzJW0mXNy2mvXXqicfam0NZZgIcXQKOgTnnyn/5tPHO0fzzml2PUVvsZK3+Bk/qbV1V4X5/SmRQh8JIcm83/xvX3bj0yIAuuVIN1+5RyiCATCguDqyrjPmBvmCtBm5T0y7k4n+XPCOEe9MBIvRP3SfZsbxxLFsF9a1xE72JMoyLqumxVhV2XUoxqmxDNVUc+69mgsIMmqwTL0aLx467qa3SemekayXjf3h59b/eQ7fT99u9+5lDsCmEsav31XKMlGVdRziXEGtjP0sgL9UE4OpxkalYddyxpDj71+ajJVYhlGtbNrtvzgAq9nWnAc4DZiL3wjO83mhF/wX4QTdq/Br96zKJNXO+qDo/GiXVh55uiB/gNjywJJcUtN4K1Do1+8va13LPetZ06cY4B48V2GvNdYHIxHLnHx3ZlvDE/l93fF6yu8ugnOmIsbQmVB6aU9w2Gf8P2Xutwily1qt64D3cKpkVxjpe/wqQTDMbPfAM4EJ/6wf5xzQ7dzac7cLlNQp9LyF+/ouG5Z5fqOWFGFhqbTz7KBnp12LSqiUGttIOgTFU2nYc6MTctSdcupZtMNUzNMWOI5+61n1s0tExrLlxQ4e69dXrG4MdRU5V/SEPre8ydBvlVQ1y8qPzGQOTmUvvf6ht3HpyrCrl+7b+kf/+duRTOcUGDOgVjZhK5bX/vquim7CgIWss76GKaPWL6oiQIrCezzOwZASn56IcKC5sHM0ER+94mpz93Wlsoq8ax818Z6r8iNJouyZtZXehsr/dcuq1A0A9vH/PzJlWE3CWKgwYJ1rD+5ZVXl2wfHasvcn7ut/f/+6HABrEKm306D4AwafGqGtWFxxe7jYJFUEXHVlHlWgfc5SLqhCeuVOVz2JJBO5RVoC1UX7AeBljmWKNy9qf7UaPbEQKqhwrft8HjPSKalJnBzhVfTzWRO8dnzydlxZ9ArURQ1MJnPl+Cyk5f1hgrvrmOTimaubS8bGId2SKaJ17aXDU8V7Q5KUI8uqwaFqPKwq77cu7w5wjB0Mqv0j2bv39J0sCexojlyy7qa773QpelWyC+21gWSRyc1mAxQx/qS1VHPfZsbdh6b3LKqaiJZzBXAJ9fWYcGgbC0cdd/mxrBf/Nr39nolXtVsjdYVCjERrNsc6U2Mxouqbu3rmirIxt4TUxhTb+4fTWTlmhj0rt57EhbQDFBmnfk0nQMY8IiIBuvMTEFTdSNb1BoqvG8dHIHVCux8706fn3YF/42rq31ufsuKyu7hTLagdQ1m79hQe6wvdf0KaLtWkMFsAMymTrvHxjPKsqbIzmOTumH3bbVV9X4P31YXSOYUFqbcYlNV4NrlFZpu5Yv6l++qT2SVV/cO/8rHlwSgWxl0uqUQ9bsPregazP7L40e8bg5buCjrbgmqX67MYSUQCAuDqytwh9S4gZur/R+7rt4lnB1hnI0jlfG5eQMyHGfuP46o8bV9I5/Y2owxFYbCR/e/PnmMY5mTQ5nP39b62VtaD/Yk7thY/7WvrA16hKqIW4J4hTlyKmla4MuWyauSAB1kfu2+pavby8rDrp+81StcTtURBkEOmNXopokQ977bg9Ccode0R2vLvM9sH8SYug6UtcV3j05IIiuwtkTHzmpfQH4A/cw5twjuFtOlYBj7PHwQLGhw0Mv7PcJEsvTIK92fv6NdDbmO9iYrwi6MqYBtY+es2kf9oktkddPK5NWPbap/+9CoqpufvLE54heXNYVf2g258PeLDs2QTyzI2mXdsxyhzhNv9/7+Q6t+44Glf/fDgy6BTeaUd4+MX7M49tbBMVsGYDRX+ZN5ZSxeLA+5Dp39+k65J1hDgL4C/mla2CNBSR9FUX6vIGtmUdb+4+nj/+MTyzavqNh5dKLdNinyufmQT3RusRG/mMoplkXFM/Kt62q3HR7/6Vt9Abdg2P7lbpFzS2CVDX7SIkfT8EE4Z6DXxYV9orPIbqt6YCQCR28/MnHbNbW/+eCyyohrLFnqHcvJKlQPf/729qHJwhv7Rx/c2vzHX1gT8Akhj5CXdZ+Lj/jFKxRFWRaeyshBn9BU7edZumc4M7v5Lkzz7CO2dlGscyAdsasGWZYGjfBpWIbOFtSXdg395VfX//K9i9N56Gz68Itd/WP53pHsZ25uCXqERfVBr8QJHLQayBTOWnnBFBXyifmSbn861lsHx/7iF9f/yRdXB32iS2DjObks5IacqP2UqB+yp5MpWVHNh25p2X1i/ORA+qsfW/yXv3hNc43f7wGpuM/DS+fpeeaM/5+9/4CS7LrOdMF7rg0fkRnpbaWpLO8LKHgPAqADrUhKFOe1Wq2nVltN95qe92bWmPXWvLXmrdFTd+t1q1stdUuU1CJFBwIkARDem/K+stJ7G95de86sfU5kZKQph6oCKqv2x1xgVkbENefeiNhnn3//m5dov31i+jtPbLZs2tkU2tFVe9/OpmMXFz86O/+l+zvrov76msDXH4lGgvoPXxtyXU8i8F6rtBUL+rT9W+rmkiWP0qBfzTM2myju7o3/55+fyxWdf/Tl7XPJ4unhhKKQP/jqjv6JtN9QdU2VGExapuYLj+5vqwnrYKXFNfHvnJr5/L2b/vA3dnc0Ribm8+kclFMTQv7hF7efGUrGwiCxG5rODkymf/vpLYe2N7Y3hP7u1YuKQkSzC8agjkW0MGOMfeMR8M7a3VP34bnZVM5Sb45QBspAHe/FD8Ym5gum7b344Xg6Z80ugkpofC5vOe5corSYNX/1wXgW1q9gIXR5sQVqQpQDW8BjyvVgABmDLg1bN4FqpT4GNdCRgB4KaeIl4gP/C/dtemhfy9aO2I9eB1/dt05M/Zvv7v9X39nT1RQ52r8wMpNtrgu6DkwpVVXJ5O3h6cw3HumZSxX/7pUBXVUUQuDgPPZ7X95+cmDx5MDitx7r4Z1AYiPTua2bYk/d3f7Tt4Zf/HD8H39t1299ru/whYWWuoBQ1v2Dz29trg0c2FL/o9eHytN4jNsR5M7mDgvc+WL6nr66aAgMN67QdtT2wG97pU0gY5JfV59/d2RrR832rlpCpF99OP7+6ZlYUH/n1AzYWdQHf/He6JEL81s7YgMTmXluIEMI6R9Pp/NWKg8GI5bt/fkvLnzv6S07u2tODCy+dXLaB13ir/Ic4HM7V3JCfvUq22FyWw+vuzVSsr3zo6lYSL97W+N/f2UgX3REPH2Z18oEDBB9+nLfdfD6WCiUTHBQHp3JZnKwTHxuNPX8OyOQyHTod57cTBmbgA7ejvCMH5hMp7KWopB3T87UREA48aM3hptqg9u7aqYWC68fm+ZZ5sudv0xIyK/mSk5ZU8Ou3qxQOTWUeOfk9BMH2+pjfvBWKzo+TQ779da6oKKAiDwS1GMhI50zKSS5VuhbZJkspEsDk9nyBnmUOZ8qnR9LSZI0NpdPZk0iy/0T6R+9MSTLUv945v/eA71+phcKft4CnUjSwGRmYiHvN9R3T81Ap/SQwVcqYIMwHZKkbMERve7hZlvauyLLc8nS0HR517JMxH7DAe29M7Mvfjh+cGtDrujAdSw5Bcv94PRsZ2OoozH09ompn7wxfNe2ekahr+rkQiFvOhcn0zfJnpxJUiJjvnZksrMpvJAu/fTNYZ+urnrH1UZ8v/eVbb96f/xLD3SBdmVVHQWDpZgTAwsvvDcqPBCPXJh/7p0RRtnRC/OHtjU01vpPDSX8hmY73tB0dmaxWHF5ErfD0HRWtBCSmHRyIPHyRxO7empdl/7ZS2cvTqSnF6Hnl6jTvDCeXsyYlLHDF+ab4v7OxvAHZ2Yf3NvS1hA6NbgINZqETEPvnqvvh3ZtUMoiQf2dEzNP3NXeVOPP5O3vPLG5tT701y9fnIUmUMqzD26qCemJrHlhLP3akclwUIdSyCU8SsMBTbhYui5VVVlV5cPn5kJ+1XTc90/PPnl3W0td8LWjk4cvLOzvq2uq8Q9NZ3mRpaSpyrunZrpboi31ocPnoRw8YKhH+xdfeH90/+a6XMn+/ssXc0UnV7JfPTyxY1OtqsrnRlPJLAS4P3h14He+uKM+5nvj2NSrhycjQX1gIjObgHpK2/UuTmRSeevVw5O7e+q2d9bmivbLH48XTJf3K7jxYWbQr8XCRqYA1q6Ee4X5IQvDfLriNxSZGCXHjQSgyVptFJQ/lu1Wki8e9+J0HPrm8Snhd6mq8pH+eZ+hqKpycjDhemwqUQgWoEkAvN9lMpUozicLbQ2ht09OH7u4QBk70j//5vGpvvbYfLr03Dsji2lzaqHAXVxh/bBkuR+enTuwpb6J69dFnUy+5LxyePKenY2EkOfeGfknX90Zj/peOTzpOrSx1t8/kT58YU4k3dsaQm8cnzoznCyazn/7xYWWeGjP5vjQZPbtk9O+S9dlIQhy50C2fOWPpTsDHnIV//Vv7nvsQOurRyZF95ZLIXM7vycOtP9P//nDibkcz4gvP0qIFA7oO7trswV7cCJT4l8MMiGxqMEoS6TNWEivi/lTOct2IDZLZq3OptD/75/e9+fPn3/544mgXyVMqqvxBwwwOSnwIPgapD6219EY/odf3PZnL5zzXEagOOxyLxHfJU/cBau9f/7C+W8/3vvEwbb/1389YrvepXqUVAP9SiWYxizJN0EcDN+Xlhvwafmi3d4Y+uYjPaCSn8//zpe27e2N/7//21G6tDovyyQA/ifUdqD1aTigFUzXtLyasBEJaqmcnV3TnnbV+TIqKSr5vS9t/4tfnB9fcy2uYshAZPKF+zs/OD3XWh/81uO9rxyeeGBP8//nL4+KwP23n9pSG/WNzWYZlX7x/qiwGxIwqIEDd4ii6S7XYuqKzv3g+Hl5fkP7F9/c9YPXBo9eWPjW472/9VTf/+U/fjCXKAYMmGlA8RwPX4oW1P9Fg7ple5kCJAIrG1TB6FABJUMVjEk+rmsXuxb71RS5YILwI+jTYmGdemwR4irIyeuaWhvV80U3X4Qa3PoY1LrNp0q2S32aAs4/S6dwAxE9vL7+cM/9e5p8mvKXv7rwwdm5oA8SsdVP8zz2P39vv6rKdTHfv/qT9y8VzPk0pas1EvRp50aTRROmMaoCRXuRgDaXBPONouX6NFggAk/SqlmrGOESr6EU22mqD5qmu5gxLcfjiWGoCyRgA685LjXh1oXK3WLRyZtuPOqLhfTpRAmKO0uOocMNYNpXbnD2iWFMioZ0x/U2t8f+b9874HrsO//PX5ds9z/+64f3b67/j8+d/ukbwyEeeq59LS/HVMtqCo7Gm+/mS45PV6JhPZt3CiUnFNDCQS3FS+F5BTMIjcAgP+oP+dWZREElch4aSsDo1cV8pu0lM5AW5qUgYP+fSJs+7olkWp6qkngEfIpSOYu3PSJBv+p5zLThM8QPljWuBHo2tbHWn8hY2QL4AN2MtqmyQg701Xc0hmyH8mJ6cHEVRRxiRl/5r+exYEA7PZQ4cXHB71s2YyGS5IeurisGUFfBucjQlALUj8Kb0+EOWt97essz93T+P/78o3BQm0+avAUHXAK/oTbG/em8ncvbDi9RZbwhHe+wAd818ZhhWl7lw03sNBzQE2nTY6ytLigRaTFjivooXYW3v+PSoB8mWfyjVc2XXMZARl/DXUEzeQf7LyEIcsdl3LnBBTlyfv6Fd7nQ9hJPE258RJbv3ta4bnrX9aC/Rq5oWw4EAZGgLvGs9vBUVlOIX1enFoszyZJwhWdM2rs5/jtf3K6pytGLC4YO67ZFy01NpKFyFIrG9Kv/hoOvLv7Jnis5dVHf1HwR1BWX/0AnoEZtawjt6KqxbPdrD3f/+M3hTMGOBK4slySSBO7X/Ct5ae1YSmYtykD/sMD7vPh05a7tDQXTXciUnjnU8e6pmVzBFv4eQQPkuTOJoqGDRU+24CykSkE/yHvG53KqAkYxIdCHXOb8ievRxrg/V3LENOBac04yIZmi/dax6VzJ6WgKlS2Wudp1ifLTvDXDKBNIhzsupDnLf5HBPMeyvWhIhzY3jHUE9IPbGhRZ3re57tmHumegxRKk37JFOxzQGWNzSUhMhgJavujMp0pcOqVWQluwyXcglA/6tepRkGUpU7AruxaN023HiwZBzrGQLs0li+BEroEFJJHlbMFazBR1Fbq0LKahBY8ozw0YWq7k2A4NBVZs/8bA78aTg4ufO9Q+vVDoH8+oYJZXVZbMn2A67ofn5r771JbXj06WePC99hoyJs2nS9mirapKtmBBHbAsm7Y3PJ3RFLAslCTwcgXxg0JCvhW37lyypMgkxOW/TILtJMCtFeKhoF+dSxZhxYaH79OLBUODIUpmrdlk0c91DCPcyUcsPUWCejJricmAdNMgRJqczzuul8xaJ4cWSyb420B5pUNPDS2+8O7YYsbMm07A0NZ+MlAqzSZLqgLzYRGh5kvOYsaM8iOfSxUNDQxD51OlGT57FJagIRDAQMuz4amMIkNBJOEnS4i0kCotpEseLzYwdFXM92YSxXBASyUsnQ+XablDUxnhrsg/r8icOAZuETuzWAj6NImAw9J8qmTZXsivaUsClRsI2Ncoyr07Gze3R8HLhf8N2jxVR+08sOb/ZRKRh6Yyq9YUeStTcMcPGHCJxQBatunT1YW0GQlq6Rz0T42FIBYnhGiaDJ1ZZ+Hm4tX5MqV0LllczJiO6wV9mk9X5tMlIkE2B5pSy1LRchLjpq6Ca6c4Ssqk+VRperEQDRq2650fS/HaD/iE0TTZtEyhlxMXIuhT4YKGdEqh9bXODbWCPk1TKgtyCILcudxZgbtHWSykzyaKF8fTlUh0LUIKGfIbkaAOxt5rnqAqcn3MZzvQ1SXog69GkZkWmT/KWE3YgGJE7mK+mDZ72qIP7235yZvD86lS2A/ym6BfFcbA3GT62sqNYDXAdEuW21ATGJ7KGpp++dyg8EWZTRQe3tsCnuUzuQ/Pzvn0Fe4ol3ytBCJvCdwVll0dw0GN8Hg6FtJtx5tPlY72Lzx2oFVW4GQ/ODNLKVRiUQ9cxgmR4lGfR6GwMgg5Jw1SceDtDcErNEMRepFLnSzMiOBMS5ab557c0jVCuRFQoeTmiw5v8VP+ahdOPrx0D3Zvux4vGF09dEEfyCcqgiLGymfhuDQSMihj+aL9xrGppw91PLy/OZ2DBfGi6UI6nEKZmsQV2JTXrgV4H1MxFNW70FSY1Sx7dVftGvq/8r+Lf4r9ShBVGPAkWI6AQgIIKQKaTKAUwaOsJgK3H9dTQ52l31CDvvJ2bjjcfDr3648nZhPFQslZcjVdHkmZwLU+PrDYUhd86/j0pZptyTK/Tzx4+zTE/I4HBb0+XQlyo1UZnIFgPGNhg0lQO1h9H9RU/VGWYDvcfANO3/VYTRh6BYjTr+MPuR7oVUTVrMQkfxTetuLWgpkS3N688PqmQfhdwdvr5qYWCg5fniKUnOZloJm83VIfhBrZ9d4ahJTPV9y3jNurc1NCWjkpCh900FnWhauviNmvxOCZQR8YHVZOVpKkWNgQ4a+4eRRCyq91qRhJ0SsgCJ9XZe0TW/qIg+crJB4F6xtJIvUxPzRjAnnPipv8ho0bZNbZ6GwuD7Zfl3OiEiakrgtZg7U9ImrglMu3RGUAIUPvV12ePufWQ2ILNJ23oiHdtqmmQRmuGD0xMrIMZ+ry0RZV+GLOIDYoxrNy5GJUHZcGDJX44ObkveqgakjsXVw18T3VWAMiRlUm9TGxIzAHw7JUBEHuuMBdkUkW7HhZ0K8F1rSJWRW4w7pwFrosrf12AMdol6/P8l/EHyFkX/qYXgqShAmKlCs6rx+d/OuX+6HojT+Ff+nCb5VP9ms6i3zRyRXslngQsmlX0nwzHgC98vGkqiquR987OWPaHv8yu6pdrz3CysHzRqRyImP9zcsXcwU7EtTfOjF9YmDRZ6jcYrz8xSrig2WDGv5iysOOtUnudZcLWuLBXMHmovxr1MksHYCqQnOlip8gFJvKoG6C//IgRlehdeK6p7/qICtnIWrFTIf+xS/Ol2yvrT744Zm5Fz8cC/pVkSGu7L1iVbTu5QZLivXCxBWp66r9Vt1gVU/2lo9zacCr7sybs8guwiNJIs+9PSwToiqwglS9azgwPm/M5u3vv9Svyrw9zbqb4nZ+4ndbjFjVka868bWuMstOfCtPn4fg61yL6j9Sd8UubpKlTDXQ4o3vT1PlvvbY4GSGUmj1dXIg8ci+1raGIPdbvOTi0qqrX31Drn2OC9N6tuqOqr4PKx9W1ce2YrhW3nurtl914cofhjevQxAhxHboz94avvoPAVUhaz/rLjWA1XcCVLWq8kyy+MGZWWgvIEk2L7GpPuVKY4FVt+W67/TKTpevQtU7dNVzuLKJ99pbeXMiCILcQYG7R2k0aPzkzWFKwUIbPskv8WEoHAhsx/ujH5xYzMCK5yfOdHATA/X0UGJkKruYLoHSQ7peRBZ2arGwZ3Nd0KdezWe6iO3fPTlDiJQ33SrLweuF2++Q2WTxR28Mqwo0Tq8WH18/YuE4HjNODizyQHlZZHKNxwnhY6Hk2p6ncM16XcxPJCloeLGwTiSpqzkytVDgvpdXqBlYu9l0zvr7VwcNXc4WbPgOvnHDu1GAs4YFi0ueOPSm4bW3N/b22LiAgshyt26qaaoN/OytkbqoX1PBWB3s23GILgul3In/ap4K7+VPeMdRynyGen40OTCZxguCIMitwx0UuHOPEXlsNicTqKy6XHAmkuKUnRtJhqHnzjXrqqu3pChQ0TWbKEaD+o1Km2jgUJ6/b1dzNKRncvYV5aRQZKkrmbzFJCirWq/v5HWdIGNsarEgrNZ0bf3U9ScAVpYdGg3rQZ82MZ+/ymax60J5Tn16EZpM/YPPbzVUpaUuyBvH0N72GOHFiH/0gxOf4Bua5+zlqcWC61KfAT1078D0GLf1uFyqVdQogzIFl/uXYbJEoiHj24/3Wg5UeaqK7DOUO+/2uTZA/FORtF8eLkT5xHecIsu5InSS9fF6ZQRBkFuBOyhwF7F4lBeSXlWWmkh1INm8XmEhY8yvq0GfBrZuN+IrmbflU6BeyqMtdYFExtKuOoF0MxayuZof7N65xOgGbx90MnUB16OTC4Vrcrtfe5SaQlI568Joelsn9JZviIH0WSKgyxeLBufHUp9gLYKb4DN++rx9zx0Zdl3xrMFkHUP2KqB0WFVmE8X3T88e3FJXtMC1ydDk0dmcbbuY4b0Mn9pbDGphweUFlSoIgtxC3EF2kLcTikKSGev3v7JDlsnz745eTyr6Fsdx6Zcf2EQp+0/Pna2NGtepPwZVsSILzWtVe3MuJ4Xe6TfRARBB1gV6J1cV7FLKbOfmq+wRBEGQjcmdlXG/beBWJPLp4eTXH+m5gYL1WxBVIb1tsZ+8ObTWGuITIBNoOluyPO7nUC5Uhd8lBn6CARC7I8inSTJnOS6YM1Y6fIX84Cb0WR8XgiAIciuCgfuGhFLwmb44npYY62oJ949lfFXW4LcHhED13pbOqMTYxfE0t9q83m1yU0UtEli/2KDiaoIgnxqxkCHz/kGVInK8DxEEQZBLgYH7BgU8gLNF+8TAwl3bGi+OZ26rmJ3Du59Id21rPDGwkC3avLTxBpzlpTwZEeQz4Sb56yMIgiC3JbetNvq2BxrCy+SdkzPtDaGW+qDr0dvJRQ4aM3m0pT7Y3hB65+SMKpct2BEEQRAEQe5YMHDfwIhe3ONz+ccPtFq2KxFIUd8GwFkQybLdxw+0js/lJxcKmoY3KoIgCIIgdzoYD21sNFV+89jU1o6avvZY0XRvm8C9aLp97bGtHTVvHpu6jT1zEARBEARBrh4MiTZ4SylVPjuSvDiZefpQu6rI11++eStAKXhrPH2o/eJk5uxI8no61yIIgiAIgtw2YOC+sREp9p+/PdJcG7x/V2OmYKtVntAbEVWRMwX7/l2NzbXBn789UjlHBEEQBEGQO5yNHeQhVJIMXRmYyLx6dPK+XU27umtTOZMQKO6UNhoyAffqVM7c1V17366mV49ODkxkDF25LVYREARBEARBrhcM3Dc4DFotBvzq8++NzCRKz9zTsakp4npsI3rMuR51PbapKfLMPR0zidLz740E/CqlrOxxjSAIgiAIcmeDgfvtALReYuT7L13QVeV/fHaHphLb9RSZKDyJfSvn3sE/hsBxKjIcs6aS//HZHbqqfP+lCxIrNzdFEARBEARBIHDa8pU//qyPAbkBEEJyRfveHU1PHWqPho03jk29f2rWdrygX9NUWZFl+dabo1EqeZQ6Li2UHF1T7tvd9Oj+1kzOevmjiQ/OzoYDOgbuCIIgCIIgFbBz6m0CY6wmZLx3eiZbtP7ZN3fftbU+5NMm5nPJrJkpOIWidQu2C1Vk4jfU2oi+uS3S1hDetinmN5Q/f37w9FAyHvE5G1DtgyAIgiAIcvPAjPvtBmUsFNC+/kj3Y/vaxuayx/oXx+bziXTJsm+5ONjQ5XjM39kQOrClrqMp8vrRyZ+8NZwvOhuxshZBEARBEORmg4H7bQUhkuNSz2PNdYGu5khfZ7S9IdwYC0RD+i3YxshxaSZvz6WLE/O5i2OZkZnszGJRUYiGxu0IgiAIgiBrQKnM7deSSSGaND6XH57OTS7kt3bWtNWH4hGfrt1ygbvt0ETWnFzIXxhL9Y9nVIVEgzpjsGjwWR8agiAIgiDILQcG7rcbEPUyKRrUJUmaXiiOTOccj3rerRgMEyIpiqwpsqEp8YghSdItKMRHEARBEAS5RcDA/fZERMCyDO2ZDKbcsl7ohP9PJhiyIwiCIAiCXAEM3G9nZJko5dj4FgWidZhVoPEjgiAIgiDIFcDA/XaGq2Zu2Ww7giAIgiAIcg3ccgWLCIIgCIIgCIKsBQN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAP3a4ZIEgE+6+NAEOTWhhD+WfFZHwaCIAhy26B+1gew8aBMYpRi7I4gyOWhlDGJ8ej9sz4UBEEQ5LYAM+7XhiwTWYYvYUIkRcavYwRB1kF8PsD/MUmW4XPjsz4iBEEQ5HYAA/drQCYkX3QkiXU0hQM+LVu02Wd9SAiC3AxkmaiKrKmyUvWLeEiRyaqftXE5pVKmYEeDeltDiElSvmjfvGn+1RwPgiAIcntwO0tl+Pr0lUJrdsVnLOO4tKs5fHBbfXtDJJkzTw4unh9JcxnrdR8rgiC3DIRItuNZDmWMaarseYxSpmmyriqSJJUsl/FaFwHjU3pNXZ0EObi1YX9ffTigjc/nD5+bnU2WNFVmN3quzySpZHuMsSseD4IgCHIbcDsH7uzGfUkSLm336cq3ntj8+Xs6Tcf16eqFsdT/+v1jM4mCKpMb/n2MIMhnBWUSz7IrqkKiIb1kuUXTq3yiGDqE76uofAIQIrke29QY/qdf39XdGnFdqirycw3BP3/hHKU3/lCJJBnaOjE6fiIhCILcltyegbv47rRs7zK5cEKWVpYVWASnDJJql3625Lr04Lb6Jw60KTLxaYpCpK2dNU8fav/LFy/gdySC3D7LdEwyLffg9vrHD7S11AUNTaGMZfL24fNzb56Ylph0aEejphCRdGeMqApJ5ax3T85omgKZbwJLc19+cFNfexQkN5qiyNITB9qPXJh/5+RMJKB7l/mcuaZDhQkGM3T10PaGoE/1eNJdHE8iax7vX7RdTyZwnAiCIMhtw20YuBMJovaasNHZFHZceqnY3XVZvuTkS06mYGXyjk9XfYYiMfguXPtkxkBI+vDelkhQX8yUFEWmlAV86kN7W3761lC24KCoFEE+fdZ6O7HrWGgjhLgeZMW/+EDnw3tb9vTEa6N+rneXSqbX2Rg+M5oqFJ3P39PhN1TKyqGz31AHJjNvHJvSeSbecWlrXfCubY2UsULJlWXiebS+xn/3tsaPzs6t+/HyiWF8GfDJu9rqY37HY+VQXlMGJtNnh5Om413rx9La8byxB4wgCIJcJ7dj4E6I7bgdjeHffnpLNm/LyjrfXUSSTNtLpM2FTGkmURifzadyVr4E8TfoXtY8nzGma8rO7niu5GgabFGRie16TbWBptpAOp9WJMxsIcinjbcmfS1fh08reDcytm9L3T/4wtbm2mC2YM+nihXZSU9rxFAVU3a7W6IBn0YpJNcpY0GfVrJckfAmhFg27WuPhf2abYNIBmpgJNl2vK7mcG3El87ZqnqDlHX8NBWZbGqKNNcFbQeSFJQxn64WbZ5KKC8KXMMmxbzlRo0ngiAIcsO5LQN3yaMsFtbv2tawmC6pyiWKtHhy3fMgbza5UPjl+yNvHJt2HEpkwtasZTMm6ZoSCerw3VzZEV9Xr4v6KUtf6xckgiA3AP6+E2/J6oLRT7IlLnFprA3842d31YSMognJcplvkoGlI1nMmImMqSmEUpDVVQJ3+L3y3ucfPpGg7vepy8t9BAzdI0HDp6uUWdzL60Z+WHhrj+eTiunFx9iK8cSoHUEQ5FbiNgzcBaBE1xWfrlwqcCfClJ0QVZXDAd2ny/s2N/z0reGTQ4s1Id31VnyzMknyGxU7uGUoYyG/hoVgCPJpwuNLJstye3046FMplUDLzR2iphbzuaKryJ/kTel63mMH2ja3R03LcymtvOEZY4osTy8WCiWnNmK4HvUorQTK4velAyMMct6Kosi260G2fVmMrnBXGa5Ev6GjQSkcgwdd4VYfzzUhE9LVGjF00PSLM6dUmlrI501Hwfp7BEGQW4PbNnD3KBSnWrbnKZf8wmFCEcv1633tsR2bagmR8qYzPpv16+qql637XUgIcdYsLiMIcrOhVAr61cf2t7bWB22XQrMjiXiU/uzt4Uw+rcjXbIZIKauv8T+yr9VyPK86aucPqQqZTRZN25VlH++aDKttXAbDdeErp/T8U4Wt00X15gS//EiWDmm947kaKJMCPuWpQx21YcPxKGxHJrZNf/LWYHrSUtYz0kEQBEE+fW7bwJ2QcpfTK5WNlh8tlFzK6BMH22zH+0/PnS1ZXvVXPyFSrugUTMcIQwFrBUbZQqqEIlAE+VQhEKMH/ep9uxq7miMWVGECjkffPjlDaepaxd1cm+7t6alrbwgwxqo/NPjSnKxrymyyWDRhR5fZDuTmuakLhPjc0YU7vUiaKqfzVgFS1/K1tI74lCCEUI9GQ/oDu5saYn7bhWSEIpOC5b52bMKDtQVYSfisDxNBEATBzqlVyIRQJj2yv/W3PtfnMa86HJfBbsIbnMrKBDwiGNfHM8ZyRXs6WYRvaPxSQ5BPCxCfULBPCQU0HmLKYorO0+SfZBYtE8l2vZ3dtSBDr1pbYwwm7YYu65o8lyiZtst3ccl3O+XFMKOz+Rw4TUmgWWGSS7nSZqGQzFmqcuN7MN2guiAaCeqGpkhVKY9PPJ4IgiDITeKOC9yheIv/rEogieXmkuWG/NoTd7Vt31Rb4tVplUddj70HVs2y36cSIqmqXBM2Pj4/n8qaYOqOIMinCIPGQ4oqy0XLtRwQxYmfTybvppQF/VpXS4RW5cNFprxoukcvLpwcTMwmixJ3arncUTFJV5SphfzZkWQ0aOhgKyNFAprr0cMXFlyXXruE59OALwuwkE+jjJVs16wez1twnoEgCHIHc9tKZdaFEEmDsrVl6arIqFVQFZIvOTVh4+m7O86NJFd+aZHDF+YPn5/f3B5TFeLYdGCx+PLHsI6sXdrfbdmW4doXyD/xa69npzeKG3gMlU195iHErTCwlzyqG3dI5XfEJ9rgpzREZd9DJRzQbJfJ3PyFECKDpuPaNwbt1VhjPFAbMVYdM5PYx+fmXzs6GY/4phYKhg4tli67MTiCkuW9enSitz0aj/hkXjZztH/xxMCCriqXn1Zcz8hf5x3CmBT0a7omgxaI296IpDvmJBAEQW4p7qzAHSQuoN5kFc9mLkJd8d3EdS/sru0NWztrzo2moNMKj+81VV7MmP/xZ2e/+kBXT1s0mTN/8f7o2eEkd4pYf3dLX3r8/4joa3i1h7r6tVf9XX49O71RLEVv4hggTXldx1AdDH528IFdulU+o4FdCz+o8jjfkANaPs1ruetWv5a//OZdLjhXCp2PAj7Nylrr9mq4hq0RQqkXCxl+0MlQ8YHAGFMVOZExf/Lm0OBUBh5iTLsKoYswkDlyYeHPnj/3xXs3RYLawFTmx28MZvI292ZhVzHy3Jvmek7p2i8opSwc0HRVAUU7etsiCILcqtwpgbuwjimYzsRcXlZkRlkkoHW1RnWVpHI2WMtVAl4i2Q5tjgcf3ts6MJERKXnxLSoTMjKd/fGbQ5GQbtne+FzOo1CLtnZ30HeFENP2bHCogBdrqix+yir5Sx8qLK4T6A/ledR1Yc+aKuuqrGmwVnCplxICglSPUv5CJp6mKkRVZL+hsPVeuGq1oXL662bmKoOwYgtrBLAyPwzL8WyXuiBbAHWvrso+HbSz4Jq/dssS6I7gYMQG+Y5EIxjRRKZgOq5HCQF/z0u68l/ieCrW1NJ1nJEsQ0NN04Lr5npUaH81FcxGGbjv3dwgpyw1XlomEm0KhCBEVWTH9YqmQ7mK2m8o11MnLXxUipbrOLB1cbvqqgzqkcuGkdCPTJE9ykzb9bzyEKkKXHRNlV13xQCV30pr7Br5kS/vR4Sba/cLdor8MVkmQRCt3YCMMJEkD3xd1epJOGNwW84sFqYWC64HAhL1qmUuoJh36LELC4upkqbJmbw9OV9Yx012CfFQyfYcx/P4W8avK7qmrG2HdE0o/M4xbc9yQGwvrqauwZVaO/geZeGgBtfLcrHaHkEQ5JblTgncRei8kC79+M0hXVMZpJfUjqZwW0No3+Y68KNwwZVZIFQ0d29v/Onbw4upkq7D1znPwMEzBqcyDmhVScivgefxmrhNlkErb7m0OR6IR3x+Q5Ekks5b2YKdylmuS4N+bV2XBnEABRPipqbaQMivhfyaLEvpPLwwlbUUhYgVgNV7JMSlNFd0/YbaVh8K+NSAD86xYLrZoj2zWJRlyW+oqyJyruCHXi3VX9N84+va2639oyRkR1XBFth6ZApOfczfGvFBJKTIJctL562pxYJMSMC3zsF7jGWzVvVfFBlOU8QcRJJ626KRoO64dCZRzBedywQVCqROl/rxVM6In/baWMSjy7M1fj4QwcEWqq6LzM+oWHAjQb2jKew3lIBPdV1WMJ103ppLlnRVuZx8onoe8En7A0HgZXvid+EI7tMVXkRIskU7GtS7W6N+XSmY7tRCwXFXFFVfGSbxNCxEeEULpokdjaFYyJBlIm7XZNY0dEWVoW57XcRML523/IbaWh8M+bUA7z2ULzoziUIya4UDWmWOxCDEh8Pz+EysemQg3Cd8vYv/jTKJep5SPU/jT1NV2fPgppVlORLU6TqthtgnGHBK4Q0CgfvS9pgk6ao8tVCwHC/o08q3uXt1g8okQ1dsxzs5uEgpfPKE/Nqlpj/84wJi6ea6QE3Y8GlKyfamF/LJnBXyazDsqybYV3deMoELqrgkHvHVx3yGpqTzVjJnp/NWwIAqnVUHQ6kU8uuqKlNTWp2LWFb9Y6kqgiDIZ8ydEriLsDuVs189MhnQVY9/iTqu19sW+1ff3rO1s6b6qxG+Sm2vrSHY3hCaWSzokiK+u3paoxFwsVhuy8KYdGY0Cf1Wq17uutRnKE3x4H27Grd21NbFDEkiw9PZ0Zns0HRmar5QtFyJrYwaOZTyEjG/Vh/z37OjqTkebK0PKAoZms4OTGQGJ9IzyZLteGtTdyLHGY8YvW2xA1sbGmL+xrjPddlsojgxn3//9OxipmQ78JyqJpGsuc7f2RhynOUZC5FJ0XSGp3O24y3/kUdRPa2ReMRwvHJnFghrFHlqMT+5WKwcjudRVSFN8cChbY19HTWtdX6/T1tMm8PT2XdOTc8nSyJxvurgFVlurPUvBwc8o8xXKqimyn1tsafuae9oDJVM+tO3h471LyiXCEwZkxpq/S11weq5AZEl03bPjaTWPr+9IdRUG1i1CDC5UJhLFyu7cPkZNdT4d3TV7u6pa6gx6mv8JdObTRSHZzIfnJnLFmwxi1tn+42hhqi/Oh/PYNaXzhddYQHuuKy1PtBWH6o+BkUhY7O52WSpUjgRMNRYSK/OuDsudVzImob86qHtjQ/tbakJ64sZ67+8cG4+WbxMxQXk0RXS1RwNBzQxSkSSXEbPDCddD27ajvrwYwfbelsjqiqPzuQGJzPHBxbmEiWY/Fxi2EXzo2jI2NIePbC1oaUu0FDjL5ScqcXiR2dmz42lbcerTA4ZAyuY3raYWtXQh+vQyGyyND6Xq8SFMpG2ddX6DbX6XAiR+sfTVGW9LVFZJt0t0er5tniTdrWEi6ar89w5ZWxoOpMtOpe6Z8Te41FfX3usrz0Kli8gUl9+yNCVLe2xSED3KBuezeaLzqW2U7VBeAt3tcBqnrTceFVKZM3R2dza1R/Po7omt9SHHtrT3NsWqQkZixnzg7OzH52dK5hwq2ztrAn5NHEjEZmYljs4lV3q7nSplRCYyQd8WmdzaCfcurXRoDE4lRmYzJ4YWExlzYrXO5e2q1vaa3IlpxXeO1Unwq9Cb2vUgw+08pT77Giq+sMBQRAE+ZS5UwL3CvCVAxJS+F1T5Im5/H/86Zk//PbezW0R0y6bNIu8ZtDQupojR/vnK02avvVYz7ZNtbyTuZAWg0ziX/y79yzbqkQGMiElx31gT9u3Huutr/FrmqLxqK67JWLZ0I/18Pn5//Lzc/mSzTO1ywcmyyChURXy1KGOZ+7pjEcMRQGtAoFYJPLg7hbH8f721YFfvjcK2fSqF6qKnLedrubw1x/tObil3qerqiprCgRGPW1Rz6OP7m/99ccTL7w3CgVnCkRaMiGW4/S0RP7gqzvLAQHXoauKspAp/dHfnRiZyfk03kCRSAxShspvPN6zb3N90XREkOp5LBY2/vPPzw1ODYcDEFUoMnFcuqUz9ptP9vVB/S4systE2tQc2bs5/tDell++P/rzd0cMHZYCKtfCcWlDLPDPvrHT5v3huT6BTC0U/+6VgUTGvHdX4x98ZVc8Bk1rNUU+dnH+yPl5lZ/a2svqenRbZ83vPrvdtt0l4QVfZsmY/+Y/vG85kNAVr4MzVZVnH+h6YE9zld82CI3+9Gdnpxfzqq7Cc2SSs73dnbVff7h7e1cc1EqqrCqQe+5rj923u+nR/a0vvDv2+rFJlcjVeXqRl3zyYPuTd7WV+PbFMXqU/n//9ti54ZSmyYosZ03r0PbG33yyb3lUKcR8//m5cyMzIz4dgkXHpYd2ND55V5sIm/gT9NeOTrx2eEpWyFce6vn6Q92GISsy2dIh/+C1gekFpqvrK5lBY+Mxf0D79hO92zpreC8h6BxctNx//X+8P5cqPrW3/X94Zms4qOsa3M6bmiIP7m1+cKL5j39wYj5tGto6SXdY6mEQIH77sd4H9jQHfVpliLZ00nt3NB6/uPjnL5zPFm1xQ/IQljz7YNeOTbVFC/pxipMKGOqJgcS///Ep4XTuebQu5vvDb+31GXyxa0mjXbTcP/z379ZHfb/75e3xiE9TZctZtn4Sb9JnH+h65lCnOF/Lof/7D0+cHFjUfOWJytoxcVy6qyv+P3xh6yrNGyxBmO6BrQ1bO2oUOHj2b//+9Nhs7vJ9IWS+TNQUD/z+s9sjYd2DO7F8Wd8+Of2nPztTfk8tHQtf6PDu3938W0/2tcQDqiarMulsiuzqie/trfuTH59WFPK9p7d0NUdMB7L9hqpMLhb+t785PpdyFO2STZFkIjkee3R/y3ef2mLosp+722xqjjx6gJ0eWvy3f38qX3B1Ha6I69LG2sAffHWnqskhv2pawu+y/IGgqcrXH+nmn3jlAfs//8m780lH025FU0sEQZA7gTsrcJcJuCzrIiRdknacGkq8eniyrWFLdVoOMpGU9XVEDU3hgSY81BwPQvy9lF8XX8nVi/kyIabjPrS35Tce27yrp5ZJEk83wlec36eqsmHoatCneh598YPxkVlwha8cmO14uip/58m+h/a1bG6NMUZdj7mQhIfXagrE4l9/uId67LWjE0LRLsKgXNHZ3B757c9t2b+1vqHGD81ioQU6nKDPUFWFNNYEfLqqKPKPXx8EgYWQCHPvy9qILxrSlxLhcJqtDeCtMTCRJjq0miJchBOP6n3tsU3N4ZLpEv69DjGxJts87wv6B5lkis7BLfXffapv7+b6oE+1+IlDPZ9GdFVvqAlqqpwpOK8fnawWzHiU+Qzl/t3NJQu2LJKvk3OFv335Yn3M981Hevs6opYDCWbQh1y2fSOlLF9yelujRdMR58gTzCCoqIv5J+byisincnGOppDdvXWdTWHL9bglCYykZXvJrCkiM5kLUe7a1vjtJ3p398RjYcPkegaPMpWArELX5PqY369D1cKLH46BEmkldTF/d2ukYJYDdxhJj/r15Ua+HqWxkNHdGskXlwP3aFCLBHXIUS+dVEs8cN/OZrgTxHwpaEzO51/+cGL/5vqvPLippT5YsiD/HvJpV9MuVJblljq4jYsWhLxQkGB7mkp2dse//cTmzR0xy/agGTCTfCHV0OWaoPHdp7f87csDC+miqijVUwIIUi0vHNR++6ktj+5raa4LiooO8FkiJGCoTTX+SNDIl9y/fvmCaXmKQlSuwMkW7E0tcC+Js+ZzJDkU0H7y1tC50ZSmSEXH27+lYeumWCU6pDz2feXIRKHotNWHOhpDjbWBXMGuvBkrNNYGNAV0+TIstnhcWna5AaGSFA5ovW2RXMk1rRVSGI/SmrDRXBsUdexX3FR5gwx8KjsaQzVRWPUSnxLRoN4/vnrZR5FJtugc3Fr/7Sd6d3ZD22YbqhXApSpu+B472DY0nX37xHRXc7irJWLaLpMkv6ZIvH7gcpeYSAXT3dsT/8pDXVva4e1j83ITcdOG/U0LKfMHrw5kija43HBXzY6mcNCv5oo2z6YvD6gsS83xgChBEfcwX5RAEARBPjPurMBdiNdFQCn+oCoQYbx1fOrz93V0NoYtu7wKzL9Evb72aMivpXO2zCPGbMFOZE17ZeBeiS1ED5em2sBvPglReypnga+a6EIuSTzGlVje9hvKNx/rIYT8+QvnKpuivFnjg3tavvlYT8CnpnKmeKF4VMTHlLIt7dHvPtU3kyycX9J+uC6tj/m++nD3k3e3F0xnMQ1xJ5+TwMlyQQVsfFNz+JuP9ozNZo9cWFDASk/y6crFiUz/eGpbZ01hKc3meqw2YtRGfNWD5nhePAqR/2yi6FEI8SmVoB9NsjQ0mYY1ASLZttccD3z14e4H9zSnslYqx6NVfuquK1k85O1uiXznic3D05mJ+bwBvnjLAQAImpkkQ7gIsWk4oDPGHt7Xdvf2RhhGnj+3HTjZy1/f0dnc+FyeT8BA6c7X+qFStqUuODKd09SysoAxiLyjIX0uVQLxfrkSkcwlSiMzOV7JwByPdTSGf+Ox3gd2N2cKTiLD1QWVgWW0aMI8Z3tX7bcUeWw2OziZhaWAqoPJl+ByVDLuInB3IPoqI/oGLKbN6oy743imvbI6EARUsO4hjtylNOhTg37tC/d1tjUEE9kS7+nDzKuz3GaMZfP2YtY0eeAuy8R2IOf69KHOnT3x+RRsTezcceEcVVn+8gNdw1PZH781pGtKpVqS5+9B4/HovtavPtTFmJQUAgyx+sHfbAXT0TXlqw93Dc9kXvl4QgGhB8wTfvXB2KEdjUFDdaHMALbmeawmYhzY0nB2JMmbj8r37mzMFR2TNzAGmTdlRdN97u2Rku0yxlI5S5FlSukKETwnV3TEEpkI3KuyxetDJMl0vIW06VJYY1nxECEl0xWtlBhjvH7gigPM73kPjpBxl0nxKeE4NFdy1q4R1UaMbzwKa1mZgk0YKLvg5VAi7ESCxlce6iqUnKLpLqZLfLlO8mlKOmd5l73QMMfQ1S/cu2lrZ818qiQRPteGTyeaL1FDU7/xSM/ZkeRbJ6aJWjlas8hXDVfp9xiTskWYTCx94q2oAEEQBEE+fW7JdiCfIp4HZgvTi4XByYxI/1XbLLTWhWqjPpGeF/pjVZFX/Sw9X2gh2FN3d+zoqs0Xba4Z4A0d4YsTUpuqQjReWuc4dH9fXdCn8ZLPcnenvo7Y73xxm6rIpuVpqqwo8JKq10LT9XzJ2dQcfmhPC69thf0ySfri/Z1PH+rMQ7wCyhB4Ffe0EXYoCt9p0XRrwsbvfmlbY22Aa2PA6m4xXUplLV1XtKVzEaY3LXUhsShRiULiUV9dzCcR0MzwZ0LxaCprLqRLmgqCH8qkrz7Ydf+upkzeFo4i4sRJ1TEUSs7WztjXHu5eK1oQg8DjBjglv6E2xYNPH2p3ParIMBRiO5cvu5Rl2bS92WTBbyjiSmkKjEbQpzXGAy5MOcTOIByprwlEg7pQ4Ihz10GEkIfFBwlmJpoq/+aTfYd2NGbztkxAj7RqYMU45Ip2V0v4d764LQh1hNV6a8ininug+mfVGchrniMuwcrRWTk+XPW+s6f23u1NhZLLRRBL43N19zxcjpU38KEdjYe2N+YLDl+YKd914hzFksoj+5rDfpDuLFc+EIj4t22q+e7TfZRLetYdIs8DDdV3ntjcFA+CRRIoqvX+sdTwVJavI5XfULqm2A59YHdTLGSYtrepKQIqdlIeHLiIfm1sPjcyk+XbBxMbGKj1VCvizXKpAV//zuE7Wtf1pfoCXX3VLzRoW3nd126fSLDc9/Sh9nu2NxaKjsrfJuVLSYiuKqblNtYEnn2wy+9TZYWo5bceP5LLnovt0k3N4V2b47bjqVy5JN6MwgoJyjZU+aG9LUGumxf31fo33nq38VWOAIIgCHKTwA9igBDp43OzJauscRcwSVJluT7qu7otENPxWutDT97VLvLH5Y1wH0bw71tKzYsU+PRiIZEzRb5Q+CF+9cGutvqQ8Iy/FIwx12NDUxnbhUP1KGtvDD19qBM8+y7rvMwk5nl0S0fNI/taLKd8mpRJo3M5nvVfLlr1PNZWD9KachjKPVrqYr5VbjYyITPJYiJr6ppSNN3etuhj+9s07glYeY448eUaRP6Xe3c2dTVHSjzde4lDhcO4e3tDZ3OYa3iuZvjL+uaS5U7MF6pF8JQyQ5eb4/5VdbGdjSHQlVTp0okkDU1muSkNiNF3bKp55EDrFQ3oxRLBwW0NB7bWQY3EZQXQNwSwCTfUJ+9q969n0XOtcB0zZM0jwXIYtxpQikMN99bOWJXshwvTfeqTB9tb6oLVroVCTVSdl3Vc2tMSuXdnIyxn8cjUdulbxyf57pZvPNejnU3hHV21hZJ7YEtdY22gkixnlOmacrR/fmaxeJm2CRsIHl579VH/04c6YTK/3imJtaBNTZEAF+hf/Y3F+HqaAXPvdR4F6b/tHdzaUBfzXafdJIIgCPLpg4E7hCCGrp4dSUFEuzLw8hiLBPWr2gq0dmJbO2s6m0JFKLBbEq/LkB8N+lRdBck4RMNg007ePTlrgl8yRPxFy93SHrtvJ+i8q7O2laCfh7/w36BPG5rKfHRunmc0QTryyL7WtoZQvmhXTzlo5VUrbA0h6H9kf2tDrc9yqETA7W5wKsPPeul5UNNGOxpCMBOgy91khOtLZQc82+pNzOe5HQqEFPfsaGytD8KJLx2G0ARzp+3qaj+nIeY/tL1RaA8uM5wP7mnhnbDK40DZ8sznUiiyVDSdyfm8trRcUP47IXVRP4/my39kjHU2hVeFNYosD01lxN8IIZ+7uyMa1IUQvPKc8hxs5QQGNOKK/MTB9qAfbBBvauROZFgAaY4H9m2us7gcmdtx8sH5RPEsaIQU0lQbcGHKtXyzrSg/5Qam+/vqq8fQcWl7Y+i+XU1FE0wkK6YxmgLWh5VGRWIq6Hrswd3NtVHDcT3G7SyP9i/MJorV9aDCwuXu7Y2Gruzrq1OgwhU2wdeRlGzBPnJuAdoC8LtCCN7WPePyzGHp52oGRbzR1t2ceOgyu/vEeJTt2VzX3RLh9bgrxmFpqg/iFlmGdPi17lpYZrGqT4/KQ6Kwpyak7+mtq+4hvdbcfd3xvI4zRhAEQW4AGLgDRJKSOSjxWy1SIFIALJyvjPC529oZ86p8HoV4Ole003mo+gKpjALr0fmic3o44ePWJSDGJeTRfa0hvwbGgisrwwwNuvz4dEXk5hVVPtq/kMiYPkO1HdpQ439kb4u9Zr6h81cZ2oo1dW6L7nY3Rw5uabBd8AVXVTIylRMi7HLACi5yrLkutJTNJR6D2UJLPMhdX8paIkUhedMZmsr6dNV2vIZa/6EdjUL+Xonuweum5KRBZ1J1RrAjdte2hnBQd8FZcv0olxCppyVS8RAEuQLXvVw+nc3N+OlMorDaoJpJNSEjKva4tIWOxtCqS2063uRCQWj6u1sih7Y3FktOtTaA8DI+0Rmn+pWKIhdK7p7NdX0dNRXHoZsEWN94IEkP+TWxG5lPOUAU9EllDIyByJsQGOTqm616r5JEetuisZDuVmXl797WWB/zOVU2o4oiux5NZaEyuWruChXbfR2xze0x0wKZOCFkIW1+fH5+VSNSxqQdXbX37mrsbolUBOXwztLl/vF0/wS0L/W4eF2UmK+rGdEU2eCPip+rWQJRZGJoa866fEbwUHlTN245xePT2vv3NFNwn1yxWVmGfLmfXwiosuUWsZ9gF0L/U76gK6uWYTLmsf199Ut12DCe8HFxFeP5CY4EQRAEuYFg4L60Uu/SgunwRu1L8N/CAe1qvjY9Hrhv66zxIDosB7iyTBYz5mtHp375/tjZkaRwHiQSG5hIz6dKQg1s2d6m5sihHY2OR4VhS3nnPKaH7pVcfipxKchCunTk/LwkMQWMI5x7dzW1N4Ycb4URhBCN6Bq8ShjwVc6RMfiG3ttbD7bQYD0pzyYLqawlGpRWOskHA1pdzCecdKgHiohmkEMsVeaVe9C6IzNZTZUdl25uj+3YFK+sV4gGTo5L3z4x/asPxnNFu3J4MreM7G2Lhrgx9uWbuRAoohVJPhjSKwbEYr8LqVI6by0nKXkNZSykx8FSHaJqEBIYaktdsHqoNUWeWshnC7aqQo3B4wfaoiF9VbqWchN0cHKsSjyXB1aCRrx7N9cJUfinYHJdrmmmDFQWPBS+nvkCX9yAQdY1RdNgqrXKPZ0yWhPWQUAFmg0iCogf299mucs3reh9e3Ei89w7IxfH01VqeIl6UixktDWEyuIraB7M3jo+ZTle5Q7l8htaF/X95pNb6qJ+xytPgPnyDjs5sJjMlpZGHuTgqkLIep9eXFu//HM140KgeGMdjbuYVAuDS76pTzzAq3dIPdpUG9y/uc6DtlMr3rwSN1YCG9nrE5SLenfeLRWWwdaUlUj1NT7xdiBSeawqfqnViKGuGs/rOSgEQRDkermzXGUuB5Ogu0rZFHH5zwHfVQ0RhMsKqY/5eOBe3obj0p+8MXRicNHz2OHzRkNt4Mm72p440H60/0LJdg0dtux5dBNv4Foola1FxJeuT4fqz+ffGZlOFKMh/dC2xru3Nb57eubMcNKnq2BKqMhbOmKGppZsT+Vf8fAdLEOo8evDE2dHku0Noafu7gj4VCGIL9fDgVVOLOTXkjlTh7DbG5nOdTdHqs9F5s2JzgwlRS8kv09tjgd4unp5JWExbS6mTU2FEKqvLaprctECGYN4VFHIL98ff/7dUcelmbz1j768vdIoRzgeNtYEpnl6+1IInbRfhyzgdKIwmygZmpzjbVMv2V2I96hP5qyFdKmtIWSDQRC4abjQy12vDRtjszlDg4x1S11Q1JKKCy1eODabgyIHCfKdfR2xykWsXFzboT9+a3h8NtfXUfPEwbZVTWc9j23fVMs7jK7pMXujEZM6yhv9WFyzlMiaNSHDLS8ZXXOCFu43TT01lHj39IzjeE8cbN+2qQZ0GsJLhEfqAZ9WLlnmE6qmuL+tIcjXiMQhQew7PJX5/ksXpheLp4YW//Bbe7gCp3zdKWWdjaFK7YSmyQMT6TPDyYNbG/KlJUN3D5LrWzth8Jcs9/nyTsl+9/SspsKkCCwU89avP5oI+bW+jkhPSwwmrmJRgMBePj43P5ssig06Hl1Mi0qS9cdEmM+MzeV++PpgR0NoZ3e8MiWjTPLryrmx1NmRpF9XPMbmUkXRoel6rl1l471tkXBAs51llTk0NdPkxYz1t68MZPJWfY3/4b0tbfWhEvSXuLbtM4n5NOXDc3Mfn5tXZfL0vR2dTRFeeM3hb6JIQJckCO5TOfOXH4wRIu3dXNfeEBKOkOLDxHPZ++dn56EGHRw2iSSVTO7zg5IZBEGQzwgM3JdJF+y1349h/1VJZYQ4JGCsSM9Txt4+MT00nY2FjeHprENprmgbECElhdMjpRAydjSGFXnZHVmk6m3Xe/3o1A9eHZxKFGrC+iwvy/v43Fy26MRC8H1fGzEauTS5Oi+nKvLZ4eQPXhs8M5RobwjVx/wP7G4iK9qy0KZ4IBrWFzKmaMR4fiz1ubvaqk8E7COblkP52ogR8mv5klNJDTJJGp3Juh7lJjNKX3sM9DZVsv5kxnzhvdGLE2lVll/+aPxrD3fXhA1PeOfDU0hPS+TkxYXL19P6DTVXcA5fmBuZyU7NF6Ax02Lx8nIFTZETGTORMbtbIrbtVVxxokGjJmzw/rJcxN8YgkCEVqXSNWjFVbIcmUgtdUFxtNVblmXpyIWF//7qwMRMbuummraG4I5NNRXJL8yIXNis36fmS86nk3EP6OrobO74xYXx2dxcuhQNGrBiUHUjXSWwDqMqC+nSz94efvXIhG1T26ZdzWFNU5ajWMpCAU3XKpUPUndzBEQvVTtTZPLG8an3Ts0EfNrwdPax/W2t9wW5hyGEgJYDAqQAHx+euwWno/dOzx7c2rCiaTFXbS2H+5LkU+UjY8nh6QzMVz1wikzn7RfeG5WJ9O0ne7e210IP0aqykPdOzRy+MG/ovDSTsVT18st6KDIZnskMz2Sfurt9V098uayZa/HPjyb/5uX+2rDPpSyTt/Rrl5tfan1va0eMruzaSwh0+f314Ym/e3UgnbMaa/2m7X7jkR6/wYtTr/quEu0LJubzP3tr+O2TM7IkySr53S9uX/W0ANi6K5bjpXLWz94eNm2vLurraY0uW+LyC/Hm8ekTQ4tBAya6jLHSknUsgiAI8pmAgXsZJkHGfe03Emjcr+KrGjKOCuHNUMsuikKXsrkjmsrbmkp07nf+0dm5sZlc0XSFWTgklQ21ryNabRHN5fLquZHkf391IFe0a0I6Y9Irhyfn08VE1vIbEJFA/F0baIeU55IUeMla+4X3Rwcm0g01/mTW/Nk7w3t64yG/Vo6EeK40HNDa6oNDkxlx2IOTmbUlZ51NoGoQDZ46GkLVTxAKlv7xtCwT6OriU7tbIowrKJaKHeWzI8mphULID36Xtkv7x9MP7ml2y/bkoHboaY2IwsrLXA4mQRD2739yyuXSfzGsl7H3451fSYpn3KE71dLReh4LhtS4sPXkZuptDUHIoS45dYgrMb6QFzUGm5rDdaJ1TlW/+nzJ/clbg4vJUl3MNz6be+Hdka08K18ZE8ZYbdhojgdgZFb24LzhiKWAouX++I2h598d8WmQxhaHwcUk17Y1EaF+eG72zePTkYBO/eytE9Nfebirrz0mHOXFFQ/7dWhGVra9Z1s6YrIMqxnlNSoCBurvn5nz6RAOMiadGkp8/j7oYLrkYQ8FwT4dykylpfE5NZiYmMs3xQP8Nl5ez6kseQn7mrdOzEAOeemdxfPoYMBfMj1QyywvkUEFRSpvzyWL0KB3aSBAAXLpMSESKVleOmdX1nOWJGGQjS6U3NlE0XUZzPrAqfETrGest1MZWikrisx1bmJvUCx+fiT5w1cvSgwMWEuW96v3xw9sbdjXW1c0V1r7X9kpSH3l6OTR/sWakO649I2jU994pCcWXJ48c7N8Egno8+mS69H5VKlkurx19PL58XkZzHzmEkVYoVr+FMDAHUEQ5DMDNe7LrGtBUe1veBmgd7rHYOG7yuGOMfa7X9r+jUe7g349W4QGOYpMZpPFslcJN8cI+JW+9qjjLTtRigLEY/0LcwlIMPO8oeQxem40NbekAXB54rwxDlqFsqQeepTK86nShZGUDH1Sytn3xUzZdHJp4xB59LRGZUjNQjQ/nyouZkqyUtEawy8tdUEdDNrh2729Icx128txFaVS/wQP3BlrrQ/EQkZllOAlsnxxImNakPAWvWMhklaWIwImSfGI7zKiDlHpe7x/4W9e6S+ajuNSx6PQ/PGK14K3vJlJFCultEvnLDXU+H0wrYIxb60PGzxwX2rbSRYzpfkkhPsu5OPDMZ6er/TGMjRldDo7OpOVRVhMpOMDi9A1aZV5qEJ6WqPXlBz9ZBCemX7+3ZHXjkx4lFmOx1s7gWHLtW4KJlrQfNc+PZS0IEyHLady5mLGrD4J0I0YaqVzrSxJm9uivF6Db4SCp+TEfD7F21QxCs+fSS5Lofg9A+seEPqLDYKVkzIwmT47khA9gNdFIfB+OTmYqDQuKB/PZV1l6LW7ylxqaxUHm6vc1BURTRsaavx1MX/1LsU9/8HZuTRv3FZxhrkmI8ilSR0p2e7x/kXhO0RkqIafXixC5+CKsRJfaggHYWoNmvurHs/rPX8EQRDk+sDAvQyRpOB6cvbSyi7ol8GlNF+CZj0VGJO2ddZ84d7O7z7V96X7N8UjvgLk2pcbxwilaU3YV91KXZbBaPlI/7yhQ8GcUGIHDNC1V55GCImFDZ+qiIaafFvgOj+1WJhNFoM+1fOopimm7Q1PZ1d+H4NJeX3UJxpSKoQUTXd8Lgf+HstbkoJ+tS7mE6FtR2MIrOkqryckkYHATgZJsdRUE1glXyGSlClY0bAeDmqRoM7z/SvsoqFzu8F7Nl4CUdv6zsnpwclMOKAH/RAy+nRoQHP5SyAcb6YXi0XTrWS95XJ/WX/Qp7muF/RrdVEoy6tcAk2T51KlxYwpevrUhI1V4gpVlYdnsrmiI6oLDE3J5u3R2fwqzQBjUl3U/ynENjIhBdN58cPxTMGJBg2/oRi64jf4ms4n2Jos501nIVXyGSpUM3NzmFzRWRWpii5Ulb6zsZBR/aiqyImsGfCrsbARCqjhIJjerAoECZEMY9mWBBL2Ln331IztetW+kBVAWG+oRy4szCdLfIVqGYW76Kwr2VCgk5Fc+bmaEZF5R6eVziuVg5SuaVNXhPCylrqYny+dVdluyiDlPzeS5PY1EGHLMozzqna8V4Msk2zBSeVMXYPbmEjQeimVs9acIJSuikMon+BVjOcnOWcEQRDkxoFSmWWiwXUMZPIlXrF6JYQBSzpvNdT4RX2qIJ23m+PBbz0em5rPv/DeyFvHZ+ZTJduhmlJOYUeDhsRNEpeV6DLJm+7IdE5Vl7LCPPEvIgdhFKMqJADOMKuNWRIZM1dyaiMQVFEKvjEjELivzgH7eF2sqPwrWe7QVOaeHU0ly4OQecllpaMpPD6XCwX05rqgSDOX89OaAh2guIiCMRYK6OWK3qWB8Cjd3BYFPxxuhuN6rLUu6FVid9Eb9dIlv1yhS1I5++RgQng4XkMimZdITi7kS5YbA5FA+cRFjjPgU+dTJS5h16GOs7I7VV5ImQkusNHASRO01CvyzVRaSJdKlhcwoOBBTKWGp7P7euts2MWyl45vKSd98xC50rHZ3PRiIQwWorCycd2Sa1bi6XZxoYkEU8cln6Gl/VaJvyNBHdaClh2L4KJHQ/oDe5qF1MR1aSzk492slndEV5Z6Q18Cv3ZiMDE6k+OynGW1mECRieV6H56Z9Tyqq2U50NLBXNK4nr9BLvP4ei9Zqve9/NZuUM0xTMUDPpi/L/cm404yM4liKmtVnKCW3OWvcfOMKSqk2MG9Z+m1HgWpz3pHX5m+XnK4PsF4IgiCIDcPDNyXIFI4AGryVaFwruhczau50aE3MZff2lHDo/AlZ2uudSmaTiSo/8bjm+/f1fwnPzlzdiRJeFJNgjR/2ZC72oEuk7PX9hat+poHOUrQp0J6dFkNDKl0LtNfYeqWypurfDB4Ql0TUQiYytvO0HS2OiYBGYOmtjeEHJfWR/3hABgjiseFAmdgEto2aapiSyxoaKuKC22HPn6wvbLELzQkdpXbt/DqubRWHTZSspyJubyqrjBevCLQYlOVp+bzhZJbG/FJkssHBjrONNQEQj5twsk31Pih1nCpkaqQ/M4kCtmCHQsbmkr8Pi6PriTsIf3vFUt8orI0kqJUkfCLW6nYJUQK+YW0unoqc6Ph2uuh6SylEr3mbOw6m5OJZDu0yLuiVg79UsNOQIXF/IamVnUwFRe9tzXa2RiuXHRh71h9lWHhSK+67nzEcgX7/dOzm9uWCwYEoCLzaWdHEgMT6Rvl5XJLwAsG/LrK7+2l+TBcBVjlsD6pL5BUXdoOy2iOUIstefPAW6P8GwrUEQRBNjK49FlGlkkQDGSqUq38t0JxHauZdV9esrxTQ0lFAe+86oco5dp3SK7rfe01/+hL2/durivxtqkQwvqXe4tWyJXsyxduQkNWH/g8VF4qvPDA86Eq5wv2bZa3IgzgWdUAb9+z1NuSzCZLqZwNGX3Rq5IyXZfbG0KWA3WcWlX0LMLckZms8AEE0YsP1g5WeulIkYAWjxg1/CceMQKGWhGQ8LgQJNGX711ftLzqgt1riloyBTuRNStFjmJk4jEjFNAs26uP+WojhrPk2ilDP1dvcq5AQLIPdhx+XmFcHYA6LjVtr2IqKDLTJctbFWIRQgJX7UH0iRGHlM7ZN0xJz4sxhP3LVR0ABO4grFgp0YbuVLVVF32VlmZdc1WxTPHe6Zl5UU9cVQUhyog/PDvHJUzXXHF7KwMDCE2RuHd++U+8g7LpeUvzyeuDQNPU22nIEARBkCUw4w4wBraP6/YFhMD3KiHgpDGXKsUjvmrTNPD64KV1WbCbJPfsaMwUrLHZXK5oS5IUCqwT6uX5Q5dBZNyrlfFC0QHzgZXPFEWiqwjyhLdwbtFVOZE2pxOF3paI6YCRuQh/G2r8qkJa64KqLAvNgxBppHPWfKq4tEspFFh9CxEC+qLqsEGWiWjxs6LLjKa43iXrB0Ckfu0GKUvjwKbn83t645W/MPApV+JRn0JIfczvM9SSZQlvExAmFZ3xuZyhKZQXWfrBa3zFBj1Koc5v5V5Me52DD15dn93rx3LcpdT+pw2lEH+rKxXThEi2660oCCFQdFGZ2QjFxeq3GF/AGZvLJ7NmfcyQqm5VUds9vVgo2V7Ap65yTtzQUApSsVXGnbIMb16YD3+GR4YgCILc8uDXRDmluqklrPMG49UwJmWuFEMvPRNqFmcWC28cm+KdTVdHVITX9ikKSebM+3c1PbC7WVg0+kQoU524hbCMXn5nMgEn7LVL6tz2YUX+214vlarKZS0Pt1CUF9OlmcXCcgqce/DVhPXaiK8pHoS/L52jrsnjc7lUtuyNzSQQ1Sy3y1kC+jVCg3RZ/EBTRpmH7+KHQNumijBjnfMDjbX7yaJ2kUQfnsmtcHfhppDN8WAoqDXXBpfV0rwLbL7kTMzn+RlBIcGKxqhczgE2KXxgl/fChIPQil1D56mlYuKbC2+4u2xc+CkiLrWuKYQXN1efqgyNV+XlH6j0rbro8AP/XLVBXiah+cC9ccVeKL8zW+tC2iedv92aVFacqodCVBZwCxmUsiAIgiCXAwN3CLYc17t7a6Pfp3pVkTs3bvNmE8WrCY9EuMYY+/EbQycGEuGgTnlB2Loxh6Epj+xrNXSIFB0Ro1d70VSKRy8F6IwpN+9b+d1PiM8Af7fq44XAesWBwn+KFg+LueRDVeRM0Z5ayC+7YXM/ymjIaKoNNNT6Qc3MX8aopGvqxEI+kbU0BXz9CCHlOcbKIdIUiNs0VbnMz+UH9TpCNZCAj8xkV+iIJMljrLHWHwsZzXUBKFpduvFlQhazpYV02bfE476K0Px96ZWibaqwMK/sgxDw7F91lFDMwBVQn0Kc+VmFskKoYztgHrhKKaTIRL/sFdfU1dYsQsW0uzveFA+Arf7Ke4Ix6cCW+qZ4kPdwvU3iWfGucVzQsqyaqAR8mmhQKv4mSlngjfZpzAURBEGQjcGdLpXhNZ1SMKBt7awBT7qlSlQoqSRkYqGQzpdtla/Ikhdh4QevDJi2d3Brfciv5gqu41FwWqtyFTdtr7Mp1NEQOj+aKq5nNxn0X7p2k+N5DMzgV/Yw4v5xZZ/sCgFDWfutn+NSluXOTRKZnC8UzHLnee5YxyIBvbctCi+vgjI2tVAomm4srAvLkALI8VdMFRReOlkyQSy0bnypgJuh6y4Z5txwZCLNJIqWQ33cDq8SBjXXBoJ+raU+6Fba/fDAcXIuLw4GQlKP8g7zS/2bysW1Mu/EWY6f+NARcLRcPeNi0Db1WkJMePJGi8lkXmzNjXeWl1pkmSSy5mIa2vGuD7fdTK2U5kOpq8Qe3NMc9Km8x9CKh2zX29ZV09cee+/0jHb1RoS3fHpeJiDAcz2IyyuHS5nEDU9X2PgE/GrIr3JDps/4LtloNymCIMhtyx0duIuoKV9yDmxraK2HZkaVh3jbHfX8aKpkeaBQv7oNCl/2D8/NFizXctztm2oiASPkV0WGsrJbCqlrua0hfGowWVpPKh0KrGNMWYmSoBU5yNlX1m5ymUfQV93gEJ6/qhxQnHXRXN4po9A4c2Q6ly2AjyTv6CTCCHlvXx03nSx7gygKWE1PLhSWWkvCf4rmCk0LaG9U5djFhfMjKX1t+Wk5WoYlDoiepRuPMK7OFezFdKmjMVTWRvPEOfjJRHx1MR+oh8pHAhd6YDIr5EBQEOky8CVcsUGmaaqfVxRUp/AD4Oqzat+Vgb2q+4VJ4IFzqenNLQsBzx+32opUCK5mk6UXPxhb5aTJXyCeBMH9+GyO+0jCH8DNxqYtdcHd3XF7jaklWfKLvHdn40fn5q6+/ZFoUHArQwgowTyPqQq80cRcmVLKTY3Ewg5M6FyPGppSEzbWGdJPBSHbuTH29QiCIMgN4s4N3IVBCohJdOWhPc11UV/Jhhx2+WEQSMj9E+mS5YrmR1eZdPIoNTR1cDL9b39w8p5dzV9+YNO2jtiKZXEiUQn84MIBzaOsaK6o4xQ1ebGQ4feptuWuUDGLDCdP91LqlUye3K2ygpZlEo/y5kHLp8jqYwHRurzKf4ZAmnzJl5o3SAfleqZg19f4HLcss/W4hiHoU0VzVlFZOJMojM/loKkqzHHY2jpUUdiaztnvnZ5Z265FlKiKp9+8DqPCkGRkOtvVHHFcEBSJzp2RoLG1I6qrSslz5SXTGY+ywakMN9SBAXEczwQjzuXYm1GQ7NdGjOpiWVkm9VF/dVdLYTVTKF3Bg2iph5SwuwEjI164vGGkzWBcCAZKrkvLnWXL0xQw8ZSOXVzI5GxlpQkMvNH4VFDcbMsdggkxHef+nc21UZ+YLq5CgR059+1q/uFrQzMJUYRQfSSwLrRykgTWlqI/7s3047w+uNupaYOgnRAFzO15t1rHpa11gYbawCx0nBVlIyzs1yIho1hy1u81deMQb4RVjVH5JPwK7k8IgiDIp8ydq3F3KcuX3HTB+tL9nY/ua3VWNiiRJegDP7VQqAgkrpICz7kyJi1mzA9Oz/7pT8/82fPnUjlLrxJJQxCsK7GQ7lGaKawWV1DGgj61tzXqUkhkQhd6GUpRS6ZbND2hZuFdWldqUYTpYdTfUAMBJa9eJZ4n9bZH4Vt/udgSfkvnQN+y9BfearFozywWKvWG3ISb1cV8kHEXmhauhk/m7In5vFDnl+cAkHGvPgpon95c5y/Zru1Q03JNy7Nsz3Go49KFdClbtG0Ijq+3bdBlgGwlZaOzuRUOg3xh4b6doia4LM8mMuTm5xIFPjPhqVCXwhoLDOzySVHKWuLBaFAXuVAZhE9kc1uUy7KXrx2lLJ23l+daYmpUvf5BJANqNrlAhkBfTIgyN5YQgcGg5Utw0SvnzmdKrKUu6ILQyLVsft1tuO6uRzMFeyFtOg4t5+mXXuNRmKDu31InyoKX91AVJrouqw0b9+1qcpwV0zwhjjdtd4XSiF9BXeN1nzDC0DH0VtPGi5lPvgQGMtUHz3swyQe31FkWODlCXE+lfX1161Sg34SDEnNd+AxcumPFW0RVoFKlvDgpxvOmHwyCIAhyOe7cwD3k1/o6Yk8caPvyA5vqY36RVxYPeZT5DGVqoTC1AF4rV79NmZCtHTGfoZi2VwumkM6RCws/f2fkjWNTkMdd2j7YDipyJKATAh6R2YJVnVCjPMS8a2tDyfJMG9TXtuOlc9bmtti+vroiN5pkTErmLNHtUiBKBpvjga6WSLYATjjZgh2P+rqbI6scnVWZjM3lRTheBRR0VlQxlVZQ1V/UjLHZRDFfhPxfWbRDpNlkcVV61fXozu54SzxIQeqgB/0Qnorzunt7Y1dzRJblgO8mdhiVeefOyYV8dZhBuYiity1afY6yTCZBsu+J8ReJ+UQWRr3yUlkGYUNPa6Shxi8cPLN5u60h2FIfgNhqJaMgBSmPVWm15AZqdutjvlwRdN7Zgh32ax2NIQssODfS21AGj1Q3lbVW5WvjEd/+LfXw3tGVoF8LGKquyabldbdE7t3ZyAgL+jQoIxEbIeCn2dMa2dJZY0M1cNX2q34XbcXu29UY9GtrzU8LK2XxvDsYmH7CugcXnxRN113qnnvroCjyfKpo2l51Hl2Wie3S+3c2HdreIP5519aG+3Y1QWHup3J38C4Q0Ka46i9QMxP0abYDFkYepQUTGhl/GkeDIAiCXIKNFDFcF6AZhcaW+/vq9vbCz/27m7/xSM8/+dqutoZwrsTbDy0/F/TcJwYW51JFA1aKr/xdJZKOAUP9xiO99+5s8ulKyQLRSU1YL5juyx+OJ7OmUpVZJJKkgr5ZLpSc0Wmusa6yOVdkcmBrQ29blGfcia4pdTH/1x7t+cajPZR3RNcUeS5VnEsWdai/FElbyJnVhPS7tjWEA9AYVVXkB/c0xUKG6y2rs0U3++GprJDcLO2RqQrpn0i7l5avQGDh0KHJTCWNLbYwvZBP5+zlEISn6tvqQvdsb1RkCM7AndqjqkLaG0Pf/VzfgS0Nq2TxNwHo7jmbLFW6XJX/Skj1NAw0QgoZnMpUJ85VmUzM5dJ5S1vqSM89QGhzPLS/r86vg/el36c+ur9FV5XquY9MSK7ojM7kxGzBoyxTWFHWLJYstnXWBHhVqyKTPZvrelqj5qpahY0ApWxgIrPqfUEpe+Jge23EsB0wdBfO95Gg/rm727/5aC+lDDyWKq/gv+zfUt8g5swVRyO+9LEMxN9Sd3NkR1cNbLCS4+eXWJj9V68mqYrc1xGDKJ+vq4QCmqZVfFpuCcS7eyFdSmZN/qZZPjjPY51Nke8+3bevr/7g1oZvPdHb0RCGFr+fyopMuXSh6hOAcrlgb1skEtRdDxbxwgGNF9QiCIIgnxl3yqcwdGV3vfaG8L/+zr5//hu7/uW3dv+fntnywO6meMxXNvdYQmi+F9KlN45NCvHx1USZ3Azea4wH7t/V9A+/sO2L922yHM+0PcdjUIcG2cIqYxkQqYO6HewUbW9gMqMoy+EF/NH1elrCv/elbXt76+qixu6e+B98deej+1t6W6Ob26K242qaspAqTfIFgZUvpI8faPvCfZtqwtoj+1uefbBbV6EWllSJVkdncqmcWe1oIYKJwYm05dBlJ8RVAygTy/EGJtMKRLTLXiKm7fVPpHjF4fLWZEK+/mjP3dsbTdstWq5fVw5ubfhnX991367Gnd21YH1zMz3Ihb1PNm/PJIt8fFb47i0/jcclw1NZ3qIVHoHOqZo8MVdIZM2KCSZ/GYSJX324+8E9zTUR/fP3djxxsH1FzMVA/zA4mS5ZjhDCUMoyecj7Vu/b9ei+zfVPHeoI+NR7djR+96nNQvK+4QJ3QsjZ0VR1lQKXJ9HdPfFvPb5Z12A6yihrbwj/zhe3f/Wh7s3t0c1tMdsp+2zybk00HvHfu7MJ/ljlQ+p6NFuw4VnlomIw6IyGjAf2NDMK99XS/uDv8A6quqTCiGZ7Z+3n7m5XVLmxNvDkwfaOxpDt3HJukoxJw9PZimqrApXY9k21/+Kbu//J13ft7olffUnu9R4PV8vwDlDLh8SbCjv37Wq6Z0eTrskt9cEv3rdJCPxurdFEEAS5k7iDilMpZX5DrYv6KsWRtuvZDqQBVymVVUM+1r9wYTwNVZhX990pjDW2dMRqI0aM6V9+YFNt1BibzU0t5Akh9+9ujoYhayV2BFG+B+vOigyB+8hsTq1SY1ci6YPbGgJ+LZWzasLGlo6Y31ANTdm/uX5gIh31aYmMOZ8qVRLDS8bzNB71fen+TTu6alrqQ52NoeqlbY+yiE8dmslkCra6sq8NISRbsGcShZ7WyDpnV07IOaOzObWq9BBCJcc7P5Z68q72pOUKMzsRw7U3hr79eO/u3njJ8hpq/G31wR3dcZnIO7tr2xqCozO5gKHerLiEX4tCyZleLHQ0ha0qs6AVyVyoEfSmEwVReMzKczZlarGQzTty04oVGNejbfWhbzzaM50odDWDbIbnict4lIUN9fxYynYoxOK831O2aEMLoqqNUMpiYeNrj3Tv7atrrg30tsXc9Yoyb3FEUcTQVMbj99ZygpZCYegTB9tqwvpcshQJ6s21ge3dtdGQ7vep+/rqz4+k/IbqilpWxrZ0xLpFs96luaKikCP9C9m88+UHN6Xztuhixvjg799S39YYnFksQoPbpfqKTN7OFCz+8vKBUErDAe1rD/fs7KoL+tVNTaG5VNHzUlAGesvk3cWM8dxo6isPdrsru3h5HtVUeVNzGByKLNd2wZn0UzkmWA6aTxVLlqPxJAKU1nDJWV3U/83Heg7taAwFtM2t0Y/PzXpUAt37LTOeCIIgdxTqndYhdTFrLkucQcO9QsfNGJQM5ovOa0emHJf69asNLrnDo3Jga73l0nzR6WgKfa91y+BEun8ibejK7t56v6E6TjlKE74c88mSxh1gBiczC+lS0Kc7HhUxDPhOcGHAXVsbVFV2XVq03FzREUqYX3ww4rrUo+zCaOqZuzuqRfjwQsvtag5v21RjO57wei/7tcNkQLYdeno4adre6riZSB6TBiYzWzti3OZ8zehJ0lyylMmv1hRRyvrH04XS8ve9wLS8fX31d29vKtlOwNAsx8ubjmm5LfHA7p740GT2pn7vKzLMQ+b4CIO8fY2iXghX5pPFVM6qXvwX2utzo6k9vfFVp2/a3o6u2n199SavPaiEm2JTuaJ9ZiQJSWj+lmLgcF9Vi7mE63l9bTFugEgLJqTnpQ2ILEtzqeLQdHZ7V01pqXgDSnsdry7q++ajvUXT5RXMMAipnF0T1vdvqfv528MOtFISIivp3p2NuiqDjmsJRZFeOTzhuOzpezuqzWcs22uJBw9sqf/Z7AjUS8AcC0o559MlmJs1hqFOYOnprse2tMf29NR5DHppcUv+Wy7GVGTp4ng6kS3Fwka1Ch90WR5NZsEOX9RAfzrHQxkU9Q5NZQqmG48YFFR+5eOxXW/v5vih7Y3iSt1y1b4IgiB3GHeKVEZACKjD1aUf4e+xlqP988cuLlRye1cDpaw24tvZFXdcqmsQH5dMt6U+9Mi+tnt3NId8aiW3KhTqyaw1MJnWVOjsMzKd/ejcPLexW96dODSI1wu2aNKkKXLBdHd01/Z1xEqWG/JrH56bHZ3LVvvVVKrccgUbqt9WSoB8utI/njl6YV7YllcjsmsDE+lq0csy3Gvywnh6zUMgKxqezBzrX/AZ6qrDKFputmg5Ds0UrJLlKtyVgknS3dsaolx5f5PEuyIlXLRc8Mm51HMYeKhPLOQzeVuVl1UxlI/SG8emUnlrybpx+YxM28sVbMiDVs1e4CWGevTCQv84XFBxBFyrY82nizA3W7myYTletmBX4t2NB18OKlneK4cn4BRWCv09sNaxbMfLFZx8EdazdFUuWe7WjprN7VEx4QH7o4j/0PYmHsdXylVJKmudGUoOTmYGJjPljldLGX1Nle/e1hALG9z5BKQdXM9mjs3m+f2/fAxi/pApWPmiY4u2vrcc0HppJlH88Owcn7qveE9xPyj+6fQpxsh8rQlq1hPZFSI6cTwla2k8qxavEARBkM+EOytwvwyUgXImFNBODyf/+uWL1b4iV0Qknnf3xIP+cvDKGCSxZJkYuqJrKyI0EY3MpYpjc3lVhQDQcum7J2eKXB69KjDm2ynHw8KiMeBT7t/ZpIP9N5lPlt47PSvL8iqLmOpXVZ+gRKQPzsxOLYLye00IDuHU6ExWOGqvDs8h1CD9ELivEGRDslmVU3nrzRPT3P9mhZcfHAZlFPwoynsTse/u3rrO5tDVW+N/MmSZzKZKuaItrxQFVTXYkifm8um8XW0QLqZVIzOZIxcWDFWBVk2XHVjxu+N6b5+aSedsXn8MYZChKpOLhbMjSf9SAFr9EmHeAbbZ3BdyI6IQ6cOzs0NTGZ+hVmfNuf0IXHTKmLjsXMHFIkH9rm2NugZrH6btHdrZAJ2wlu5bSpmhy0cuLGSLIHA6O5wUTuZVoiZ335Z66Ki1ZE6qyGDYOswVO6tEUEvHcJUyt88APn9z3zk1I26wNRZP3KWeMkNTVonobuIhSVB9fnYkCbfvmk+hW3w8EQRB7hzu6MCdx1gQYXiU6aoSj/iGpzI/fH2wfyztW5nGuwLQX4Ye3FLv0xUQ/vLoFuJsD7yrTZvXpi7tUTz0zsmZco9S/vV8aijx8bn5SEBnPNxZ3jC3T66k6nk+WO1oDKsKlEvKMnnr+PTUYiES1MV+175KpNO4Z7Y+MJ55+8T0pWwhCCHJrDWfKkHjJLa216M3MZ9bd0xURf74/PzpoUQ0pPNvd7bqMCpr/iJAqY/5Y0H9pgYBjEq6Ki+kimsT50vHBnWQM4mivayyWMZ12SsfT+RKdtAHUWnlSFcNrDjZaEg/emHhiFjHEH473PIvW7BPDCTE5GRVSljm1ckhv85VUlAIu7Ekw4x7Is0lS78+PKGqRFOVyiBVLndFhQa3NJWCPrWx1g/3LcToyj07msRjlW1SKn18fl5s56NzcyXLq1w4EfpHg2DoXlEfCePzj87NL6SLPl2pbh60dAy3tKxDV5VzI6nXjk0GfRqXDInIGP4Lg8BYyK8NTGRmeYH1qs5T7CapZVT53ZMz2ZIDVjwbbTwRBEHuEO7owF2WIW+nKbJPVyzHm14s/PTN4XdOzoSD2rXWTRKZZAoWl/YuG6aJliXVXWBkWTI0eXAy/eaxKRDQ890oMknnrRfeH51ayBu6sm6gKV7r05Vs0e4fT4NrG9cPDE1lXvl4vGg61ftdhSLDCSaz1i/eHxuZzoj9rnkWU1WSLTgj06C9qX4C2GPL8myymMqu8DcsP8onHvPJ0i8/GJ1LQO3g2oapFXQVHj05sJhIm8rNDFbLkWWqmM3b2spuSkuqdJIp2LOJwppJCqAq8qnBxJvHp0TW81LnoymgdJpaKPz83dGFVMlYsuYUaxS6opwZTo7MQhnu2sODG0ORXvpwfHQmJ8oDNhJiqYCQt49PHz0/r8hE52161kVRZL+hzCaKF8bSEgMdC5gjtUYrbzGoD9GV6cVC/3iKejTk004NJWBYqsqgQbBhuvfvaqqJGB5P8FMGtebnRpPvnZ4Fo89L33W3IKKWPV+0f/jq4MAELGT5dEVTZEWRxceRoakzicIL740K56jqSTnMw9fY0dyQg1IVcm4k+TG/oFUNmBEEQZBbiI30bXdNiO6Dl/mhVfoNRSZnhhJ/9IMTrxyZ1BV5bU2hwKPrbHNJX6H83WsD75yc9vGw2POgf7jIPgvtBIXjAdc126E/en0onbcrcTborTX5+MWFv36lX1wSl5tec50J/y/sFzZlaMorH088986I0OcI48WfvjX8yuFJUOTz/Va/kB8wBFmqIv/4zeFXjkyApna9IFE4XWTyFjQchQo56HkpfkSF39BkugC9Wtfpf847RkGu7m9evgjGiFzSs/YwPEoNXZlPFf/0uTNgpKMoIp4WtiGrftaKB6716qtgdV9KZi1QHaxSvEhMleVExpwuq4ZWvpbPkRxKv//SxSMX5v2G6vFQia46IworHh5lf/XihSMX5o2VSUrosaUpQ1OZN45NgZKqsgX+ctelhqb0j6feOTmTztuOQz1v+dZaNWnkd86au/c6FizW3sZrb3h+y63eafU+KWOqTOZTpT/92dnxubyuyetedBgl7k/y928MvfzxuKLIlkv39cXrYr6S5YkjcTxPU+UTA4nJ+YLQ0uSLzkfnZh0X7pml+4HaLm2oCezbUmc74CkuuuGqivzc2yMjM9AJgd9jKw5gvQnqJVl/nNcTsVzxdmXsys+hjGmaPDaT/bPnzw5OZny6QvhZyTJ0G2AS+5uXL75/ZtZYWfoC63guvCWr43YY5yu9fdb97Fp1E/HSWPbTN4dnE0VNg5r48mCK8eRrAlc/ngiCIMjN4PZ0lYFCTENtqQ+pCtGU9XOBedNJZax0wZpPmScHF08OLvaPpyybBn3qpaLGeMTXXBe07bL8XYjORQwhE2kuUfzR64PZovP4gbaWukDJ8pylbz6og5XlgKEksubfvz70/pnZVWl1RZZN2337+HTYpz28r3VXb1zi3/08tQaPGro8CZndkV+9P5bImP6lJK6iyKmc9dO3hj2P3b+7qbMpbDvwtU0pUxTC9wtZtHdPzbz04Xih5FzGhFEGd21vNlGMhnSfofCUKvzd9Wht2DexUMiV7ICxzlqEUIaULPeN41NBv/rwvpadXXEmMcctH4amyqosp3Lm68cmXz86eXYkBUG8ppaT3zJpqQsWzXKxJmOSrsu1EeM6gwQ4HcdLjAzZWgABAABJREFUZc2GGn/Ap2YK9nIQVpbm21OLBW1laW/VFSEzi4W//fXFbMG+d2djY23QssGPX2TrVVXxPHpiYOHtkzPvnJyxXU9M2Kq3IHRQL380HgtqX324x9AUvgUYEENX+sfSf/Vi/3y65FHaUOtzuI+HR1k0qAV9y4PMmBTyac3xYEVHThmDvqQ+7ZMNj0xIPOorDzgvRIZGvxatLrdlTIqE9OpbHRqjhg2+pFB1grIkedLFicx/+9WFpw+13b2tMRLQLehawIgEF11TZcelZ4YTbxybeu3oZL7k6KrS0RD68gNdTbWBgumIeSBMk1wYTMelPkOlHlVk8v6Zme891ddaH6x0DxNv6m891vvx2flyJQaTDFUen8v95a8u/NYTfbs31zEG8T0sCBDi0xXTgffg1dRAUwbd02CclzxeHM9rqA2GAytueHH1m2oDoYAhbOwp17Tw/sHLl0zXwEW+NuoTW+OXVa8JG6t2qhCZEnp6KPnffnXhwJa69sZwLGxk89b4XH5yIf/m8Wldlctv2ConJ5eyaitSWSaNNf7KxRILETPJwqrS55qQ0VIXLJTKbkjC2GpVkTqDNTF5YCL9ly/2f+vx3h1dtY5L4XLy28bQFPHZgnoZBEGQz5DbMHAX9nxzieKL749lCla1fWE12aKzmColsuZ0ovjxufl8yYmFtMtE7UySjlyYT+YsETQsRWYQ7Ip/RoL6udF0MmfbNt3RXVMTNkJ+XddklVdklix7IGeeGkw89/ZwoeT6jWVZcMVjPldwfvTGULpgp/N2TdiAFXMu3jVtcHU4M5z86ZvDc6lilDcyFC9mjIWDIJX+wWuDmYK9r68u6Nd8mqKqsmVDB6hM3n7v1MzLh8dLphvyq6uqLVecIC1rb37x/pgqg4ZenBelUsgPNbvlytT1NkApC/rUbMH+8ZvD6YKdzFi1UZ8PCnMhWs2XnELJmU0UX/p4/Gj/QjQI8hOxfYXbv7z80QQ04qm47qjy+bHUpS7cVQK24pp67OJCPOYzNKWnNcq7zC4/YR5KV51YUF/bxV38IeTXjl9cLJpupmBv76r164pfV3l9rWs6dCFVfPPY9BvHJ5kEFqJrk9bCxmdiLv+jN4bDAaMpHgj6NCHKSuet149OvX1ixtCUcyOJlz+eEEE/pVLAp0zM53kDAdiIIpOxudwrhycqdRIQrerK1Hz+E5jS8M5H3uHz84sZ07Y9IvPR1uT5ZMmyl8dfVciFsdQrH09UbnVxDySzlqKAL1DlSBRQd0hvHJvKFa103u5piRq64jdUSmm+5BZMJ52zj5yff/GjccpoJKDn+dRxcDI7MZ/n3uvl3aVyIADT+aoF4xqk8bn8ix+NN9UEXFaOFMWNkcpZcFM5XsXlXVXkt45P+zU1XbAaav0+HdoN2w60Zxqby8+limpVk7J1EVueXizAOPOpspirxILG0HS20sxBCJwKJffN49MwweCBu1C5jMxkRYmzeE4mb791YjoU0MTW+GVVTw0m1taLqwp8OLx7aubiRHpzeyweNVIZa2AqPZsoqorS2xYN+FZMCMVylsl9jcT70Xa8d07NxKO+ymRG05SR6Uzl2okTPD2SMHR4M8J0SyTXHdHrqrrYHLbPCJhy6qqczlu1YXgXy1BKy8dzNpdfCv0RBEGQzwSy5St/LN2OCIHK5Z4hgm/+f1BLdxWKawgq1jxp7deYR1lLXfCuLfW97bFYSA/61FTOmkuV3j89e3okyY1kLrsXKkWCWk9rtDkeaKjxm7Y7n4aIfyFd5MaFl4Qx1lQb6GmLNtUEQgF1PmXOJYuDk5lMwbn6PuVQ+rZemHP1pWmUgoVIX0esJR6oifjmk2D4PT6bK9kehADrjfM6kgZeDyddN4SQQsnZ2V37v/yjQ9EQlPCKrSoy+W+/vPBXL12IBPQrynKYJHU2hDa1hJtqArquzCWKM3xgi6Z3NQPLA1zS2Rju64jWx/yJtHnk4vxsoiRmJmtv1FVDve6dfD2VguvcxmtGu6rGuOpZl78kRNrcFmtvCDXXBkzHHZ7KDs9kk1lrlR35+jfYepd73bfbuu846JBFWSSg7d1c194Q0jQlk7cGJjLnxlJXP0hXP85Xc7uufY4o2F27XxFtl41x+GSGiBmC6e7urv1ff/8ePnsvL+CEAtrH5+b/8E/eC1YF9J/4gl4mBOfNwvT9ffVN8aAKRTj2hfHUxck0dBdDEARBPjtuw4x7pYeoKZKIl4jKCCHCKlkmsKx/NZG7kDqs+uIK+LTqxu/QkNXxphby+aL90XlwGlFk4rjUdr1UznIcT4Gs7QqbkeVDWlLQJrJmyXIHJqF1K/hUOl626HgelXU45nUiKp6Hsx06tVhI5S2oEOVu7pYNPZigKhSOYv2drt6Ox0xbdLdcPqxy8dwaOfhljv/kYKJ/LKWpkBwtWW7JAi2IoSqqutpskjJWtNzqURVpVGi1cx3I/Pq6HoxeQ42fi6orrYKIaXmVLOnlzoj7mTguHZ3NzaVLhqoQWbIdajmekJroS307L7MFSlmh5A5PZ+dSIKl3XCp0O4oMWWPbpY7jVZ+7oYGFaOXAXI/aVU+oPKfsGX+NMLb6Nha2934dDEYrx2w5tFqPIZ7mN8C/dO3JEhCWwPMHJtITc3lDh8R50YSL7nhMUwi4l5aDUhiNku2tuheFsmVVHGnaoKpedeIyIX5DXRsAex5N5qzDF+ZPDydlbhlUMJ2S5fq01Zu9zCeGZXurbntdU1YJhChbffwiyx7wqZW/iVWy6kh5nVuaZ+LDAW1Xd/zw+dmi5YE3DoTgcN/CG1iS+jpj0ZCeh9qS8n1LKVvMlLyqS8MYNDuD9auVx+PTV4yS7VCwwF9xzpJYQVp3QFyPLqTND8/OcedZ8FniDdQ8/8rNIgiCIJ8yt2fgDt+4KizZX/455UQUTwFejaI6HNDXfmk5VU1JuGCXhCGJS1M5sFYUFub8mxhiI/HQpfYlIhu/Ad/ujktLtudBuxmonYX4w1Av9VrRFTXklz0qFU3oscrF5aDSEZYmV+nBLFRGsdBqMS4PjK5cmiZMu8Ww245XMh0u6QajjHBAFwHN2o0oMlkr/xXVnNInhbvje7btybIc9KuPHWgrx+hL6XbbpaMz2SvauQhbd0ODwsdCycl4tih7VRQS9MFprinwW2cLiiKHNcX1aDoPIbOiyD4eDIl7w6crYlMVVlVVGroSWPmEtc+5hpEh69zGopiy+p8BQ5X9q+91XiG9XmWzBAGuT1cdl+aKdjoPsnJNlX2GGiSguaqMEi+HINHgOgew9t6OrPd2W3WolQMQd13RdLMFh3GnVF2V+XLKVVVUXuoTY+04KzKJBfVVeedVR6UoJLLmHEW97PJzCCnazrbO2Dcf7elsCr1yeGJ4Gm5IYedSyrqb26MP7W0VufYKrscW0mb1XwgBkd7lLyjPL6wTo6+tT63gN1QmSbmi41G458F9S1VgPK+zbBxBEAS5Pm7PwF1EfpXG3TeKtRHDWsRXJiGSz1D9hlj4LvciFbYVV3j5ktk5hN2KJIkUHV/Ev4w8fclFB8IJMOYri4KXt3b1MAZFpdf0krXdhYSjYqWNKJMud+KMrZj83BAok9rqg4amziYK7U3hHV21RRP6W1Ws9NN5ayFjXildLjbFqAcv0VVF18QRw/+ufmDFtYNbQlPggpZdhpa2f6UQ/IpPuBm3sbCIufptwkFKDNxOZUUiynL7rTXDu27k/YmPs/qAhd9o+Rot+Urd8E8MuF2v+C6+unNkjO3sit+1tWFze1SRyetHp2y3vLqiqPLThzq2b6qBXrNVKyEepVMLBejzdZMvqHiyoS19mFz7eCIIgiA3g9s2cP9sWamX/SRRVzm3eY0v5b1L11cGf8qsq6n9NPf/5fu7dnTXvn9m9p4dTbEQCNmra/UGJtOexxR1HeHH+pvjwfr1DOz1b+HW5zM/x0vJ4m81CIHovy7m37s5bvMZ+dcf6X7yrvax2fzQFNi6b9tU09ce45PM5TQ5VHKbbv94Sl2n8/EdPZ4IgiB3Dhi4I7cbXH+i3ruzsaU+FA3pDTWBFWpjbmNyrH8B/nE1JckIcuMBFX5LXXBnd7xguoyxSNCIR3y1EV9XSxicZ6PgjlOy3OW4nd+o04uF2URRWa/QBUEQBLkTwMAdud1wXdq1qaYu5rdsrzke4BWHK5rX5kvOxckM2mMgnyGU0t098WhIz+RtRSG5IkjzNVVuqIHaAsuhBdepdkT1GPNze9OS7Rkr/dcRBEGQOwcM3JHbCkKIx9jd2xtVReY+IVDdW3kU2tPo6tnhVDIDNoWYbkc+EyilkaD+wO5mE+qn4f5UwXcHfrEd0JFDi4OVBaeaIueL9gdnZ7m/DK4UIQiC3KF8Ekc5BLk1Ee6fmqrs6a1VuOfmKrcNz4Ok5rGBhWzBEvYdCPIpIzxGu1ujWztjKwwolx5daxFjOzQc1N47PXtxPHNFV1YEQRDkNgYDd+T2gRCpZLv7N9d1NkUsnrlcZQYS9mvD09n3Ts2Ahf9nd5zIHY4sk3TW6h9Lx8KGLJe9Vtl6Be7C3aUmYpwZTj7/7qjjUuxbiiAIcieDUhnk9oHwmr/GuN/QFFWB7ksVWwxZlgK66nj0lx+MDU9nAz7lxnosIshVAuXRMhmbzf3w9cGAT22pCwZ8qkupt6JlE9yxMoHGaR5lI9OZH7w6eG4kaWjKZ+vWhCAIgny2YMYduX2gDNoVnRtNDk2ml9pO8cQltNiCppsfnZ17+aNxXVUYGlIjnx3Q+1ZXPzwz9yc/PjU4neVW/WUzzcoPXWqJsJgu/enPzr51YkpV5avrFIcgCILctpAtX/njz/oYEORGIhOypTP6lQe7d/bEW+uCqkIolWYShVcPT7z08cTwVFZHUw7ks4YQYtquocmb22N3bWvY11e/tSMWj/hgHYgxj0kLqeJ0oji1kH/r+MxHZ2dN2/MZCobtCIIgdzgolUFuN1yPfnx+gTHp4mSmtT4YDej5ojOdKLx2ZHJkJhsNGSiSQT5zGGMBQ/UoO3x+fiZRHJ3N9bXH6qI+Q1MUQrIlZy5RnE0WpxYKp4YSmioH/erleycjCIIgdwKYcUduQ2SZOC51PKoQKRbypXOmJ0mGqiiQfcfoB7lVAA9IGe5J16Oux4gsRQO6riqJbMmj0CpVkQm3P0KJDIIgCAJgxh25DRHRuUwIYyxTsCgUcxCIflDajtxKsKVSDH67grY9X3KI5PKSjPIToMAaQRAEQTgYuCO3J5oi6/zupowZEBNVAiQEuYVgfIFIUcoGpYxCiaouw70Ltyu/bz/rY0QQBEFuFTBwR25PKkaQhPdd+qwPB0EuibBsF7+Lxqh4xyIIgiDrgoE7cpuDERCywW5XvGURBEGQS4A+7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCOIAiCIAiCIBsADNwRBEEQBEEQZAOAgTuCIAiCIAiCbAAwcEcQBEEQBEGQDQAG7giCIAiCIAiyAcDAHUEQBEEQBEE2ABi4IwiCIAiCIMgGAAN3BEEQBEEQBNkAYOCO3CkQaWOz0Y8fQRAEQZDrBAN35E6BShsb9lkfAIIgCIIgny2qdJuiyISQ6hwlo0yidHXwIy89hzKMi253GMS+K26KjYO4PW/SwfPNwtuF3fy3ASFEJvB2wzccgiAIglwrt23gni85luPxYAREBgohmib7DVViK2J00/EUQlxK/bqKsfuGQESZnyDuC/hVRlnJ8jZi7O43FIlIpuVd/6bE6VfGjxDJcSmRJI8yVZFl+UaODiErrhSTJNf1KGWyQlQZl/sQBEEQ5Nq4bQP3pnggYIhYHEIH12Om5aYLtiITVSEilqCUNdUGtm+qOTW4mM7bssKjfOTWhvJs7bXGl0yS7tvVVDLdN49NG7q8seZosizt76tXVPLOiZnr35rH150qa00Mtk92dtXqqnxiMMHYDcvrM1jjotVXilLWHA/0tcdODiayBfvGThIQBEEQ5LbnNgzcGYNA5KlDHYd2NJZMlxCIVFI5a3Ai8+qRiXzJJTxYgUSjR+/Z0fgHX9v5xz888dw7I7GQ4XkbKqC7I4FVlGuM9wiXQn3j4e7FtPXyRxM+Q9koQg1CINhVZOWpQx2Grrx3ctaltBJzfzJkQionT4jkeizs13/zyS3tDYHf/6O3cwVHU5afcJ0HX11SK87lnh2N/+o7+/7lv3v3w7NzS1NrBEEQBEHu1MBdhAit9cF9m+sYg6BHJpLtevNbi7t64n/9Uv/AZCbgUxmDEL8u6uttj8UjPtdlG1FBcYdBPI/WRAy/rs6litf64nBAL1neBg0UA37VryvXvx3GWDzqJ5KUyJZEVM2YpKmkvTHY0xZVZaFsue53ApGox4J+LRbW55MlmGyIfUlSPOJvaq2JBPUNeiEQBEEQ5DPk9gzcIelOSDZvv3Vi2nKorsqxsN7ZFP7yg12m7f7pz84WTFeRiSKTC2Opn7053D+R8ekKW7IdqZS1rltBJx6Fv695lAhR75qHVil9q/6+LDUW/xTJZJhTsPWfKbKta/OUqza1rpp5xfGvPXh+VuxKR3j5w1i106WxWj/BXRnJ6ocvdcx8DkaKlre7N76pMfK3r/SLhy4f/y0NKZxYvugU+ArMqnMRz6kekMtciOVSzjVHvmazq899qQT0kgOydlOQHec3VNF015ZWX+k4Vx8k5LyZdO/ORupJv/pwVIjMFVkqWe7bJ6bPjqQs24NpbtVVuOIxr/tmkYlkunRrQ/Cxg21/82J/tkSJTJjEZCJdGE//6vWLU4sFVSHVPj/lq3CFIV06342yYoIgCIIgN5TbNXCHIG8hY/6Hn55ezJi6qtTX+A9ubfjtp/s+f2/nmZHkL94bU2RZVciRCwuTC4XpRMFvqEL7y0XAVASwZI0ogUkS9crxxtpHKZMYpWsf8i4hb4BQrMr7Rqi3y8FQ1dMhmqFMTAlcvve14uBVm1r6I7x61Z89voVVuyhvQVp/v9XPEf+81GEs7ZQHW/A7jOTafVWGRZQOVw/O2sMQzyT8jyXb3dVdu7+v4fsvX5AYHMz6m14liOfPURSYqq0dMUrBTKXahQiOi0/j1t185dFVRy4iXcaPqnJ21VtYvj2ucNTLRwi74reEmGde6kjW3WDlNhaXiZ8pHOGh7Y1F033+vRH+5ieyTAqW+5M3hyUilRwI3Pl1548R8NBkl76IlUu86p4nEjEdt60x9Myhzh+8Mui4lqzBozIhR/vnh6ezi6mSBiUlbPW5rBnSlVdq6XyvUy2EIAiCIBuT29nYARKWMlG4/VwmZ795bOr7v7pQNN3P37sp5IcwnRDiuHR8Lud5TMQBhEdIlDLbpa5HZb6FygZlGQIGVzxK2apHwZGDK4b5Q8thFmNsba60KpIrPwQBE5PEfsWRLz+PwbN4/hUiZmdp5lD1OIPTWXP6ksQ8HquVd6FA8OVRBqcmwz9XH8yqhDvfb+XlUGvID0OUDTje+vpkHrvC2MpE8jzmuLCNVUEnIcvjDIO/FBUyBi9ZJWIX2mgYRsZUIhuaIiY44O956bwr4ZeAMrBMkaR1ilnhtUyqPIey8gDyQ4XDdtZcCHHYoAtfOnKZ/3PVZkWmnIohWjp3fvPAC+Hyrbq+6xx89YGJQ1qN+KM4zlWTKPFyz+MHye9zeJSbMKoyMTS5MoDw/0xSZTmRMRdSJSFoqVxEccziIq4dQ2Xp0bVvFljykohfg1oCfuXKF0uWiWl7Uwt5l9JKDSwh8N6Bc/EoF/Tzo11zpcQfHX7/w74wdEcQBEHuPG7PjLtAJiTgU02/pqnE9STTct84Nv3Ygbb7djX3tsZODi3KCgkF1GjIyOTsguUoskwpLZluT2ussdZfNN3+sVSuZId8mnDeKFmupsg7u2tCPi1XdAYmM/mSHfJrQpmTyJjRsL6rp5YyqX8slbXcaFB3PeY31KbawEyiYNpgPSlCTcaYrimNEaNoutmCrShytmC3N4Y6myKm7Y5MZ9M5K+DXRDI45NfCAX02USRE2rO5nhDpwlhKJKGFXiXo02ojvsVM0bQg1hRhq+t6sYgv7NcW0iXboYpCYJuGtm1TjarI/ePpdM6KBHURZikyaagJWLabyls8JCKUUtAoh4xE1rQcT2KS36dEg8ZcosgkafumGp+h9o+lwXNTXm4ORCmrjfhUhcwmi7JMtnTEoiFjdDY7vVAQdQVLgbhUctwtHbF41JfMmsPTWcq9CH263Fgbmk+Zpu3yp4octrSpOZIrOqbtdjaFgz7N9WhTPAAPUZbKW2snLTIhjkdN2+tpiTTWBkZnsjNJromv0sm01AUKJXchbXY0hbqawwMTmYW0aehytuA0xwPdLRHHpUNTmUzBrliFeh7LWk5dxLe5LRoKaOm8fXE8TQjRVJh0MSaFAmrQp82nSrbndjVH4xFjbDY/kyhEgnqu6AQMdcem2oBPHZhMJ7NmwNAupTWiVMqZ9qbmSGt9YHI+P5sorZjJ8OubLzl1Mf/mtnrX84ans6ms5TNUkZ6nlBUdd1tnTW3YyBWd/vG0ZXtBODa1PuY3NJh9NNcFZJk4Ds3kLUKk2phPU+SFjCki7dqwT1XJ1ELB0BV+EfXh6dx8smgYSuVaZ/J20K/1tkVrw4Zpe/0T6ZLlguSMwZywtT4Uj/pN26ur8cuyrKpw+5m2F/SpdTH/fLJoOhB/i5NN5UrN8cCu1tpsAY5WIixkaKIcgUhSc12waDoLqVI84tvZUisTcmYkYTmerm0wdyAEQRAEuU5u58Cd8UiLJ7BliUnhgJbM2R+fn79vV9PezXXHLs4rstxQ4//c3R2vfDxxcdISxtI7u+NffrC7qymcKVhvHZ8+fGE+lbVkGVLd4YD+0J7mB/Y0xyO+RMZ89/TMx+fncwVbkqD4dUdX7b6tdYe2Nboe+/DM7OH+hflkkVIpEtS/8lDXK4cnTg8lRJZRBk0C7WqJfOHezufeGcnkbcv2ulsjX7y/c3dPXdF0Pz43/8qRiXTO0jXFMr3OrvDd25p+9PrAPTsbP3eoI1uw/+jvMo5FFZH8dmk84nvm3o6Pzs0d719QePKSgJqFHdxa390S/f5LF4gkWbbX1x7b3Vt3384mRSEfnZs/fH5ueqGgcHNMv6E+eVfbyEzuzeOTBogYJMulbQ2hR/a2/OL90cmFgsSkpnjw/p3Nv/xgbGtH7Iv3d7ou/ZMfny6mXI2LK0TSt2S5e3rjsbDxi/dGHz/Yds/2xmjYODm4+Iv3xhbTpUomlVJ697aGp+/taG8ITy/m3zo+88GZWceFqO6BPc2FkvvcOyMQnvIMa3dL9KsPdf3y/THXo88+2L2pORL0qd96rFcEr3//2kC26KzKSXseVRXy4J7m+3Y29bZGTw0nfvH+aGXdg1JJVcgz93R+dHYu6Ne+8WjPgS31/+Gnp6f4aLQ1hL58/6a9m+O2Sw+fn3/1yGQiY0LVpiTpmtzeWHPvzsZd3bWxsG9qIf/60ckj5xdE+OhRuKbbOmtfeHfk0OaGR/e31UWMk4OJt45Pnx9PNdUGHt3fdnBrg19XPjw3+9qRyUTWWjeVLpLR9+xofGB3y5bOaP94+tcfTXh8haeC49HmuuAz93Qe2t5gu96x/sWXPxpPZEwhdKGSdGBL/bMPdLXUBRcz5tsnpo9eWEhkSwe2NDy4t6W+xu8ztG893qtrythM7pfvj5qOd2BrfTzi//Ebgx5P89+1tUHT5RfeHXnmno67tjRGw9qxi4mXPxybS5WWFhCk9sbQwa0NB7c2NMcD6bz1zqnZd45PmZA2Z7Gw/uUHund1xXVNefaBLtP2JIn9/J2R/vF0b2vkqw/3fP/F/nyi4NNksXp0aEfT/r66/X3188nSB+fmjl9cyOVthU+HJEl66u6OI/3zikyefbBrx6Zax6P1R33vnJiBdQBMuyMIgiB3Erdz4F4NV4czXZXPjyaTGXPbphphMt1YE/zS/ZvOjiTPjaWoymIh3+99ecfu3rhle7Ic2tld+1+eP//c28OGrHgefXB387/8jT0g6pXlTU3hvX11f/b8+V+8O0IICQf0f/4bu3d21bpcHXFoR8Orh6f+9x+csDxPlclDe5odj54dTonIUUh09vTWfeOR3p+8OQwCa5l87+mtjx1ohVY4RNrRVSvL0g9eHZQJsV3a2RR+9sHOgYnUP/zitrqYb2gqC8FTWbUCwY2qkIf3tvoN9cj5eVXhnh6MGbry5MG25rrQn/38rEyIoSn/6Nnt92yHeQVjENN/cKb+f/ubY0XLZYz5fern7m5//8zsq4cnfDpMLxyPdjQGv/xA1wdnZsfn84xJLfHg5+5uX8yUvvzgpq3tNUPTGeGrSCRZaGzgaB26Z3NdX1t0fC73j7+yQ1Vl6rHtm2p0RfnzX5yr+A821vr/+Td3N8cDLmXdzeFtnbXpvHni4qJpe611wYf2tnxwZmZ6saiB+og8c6j90f2tz709XBf1f+HeDtPxiCQ9eVe7qpD5dOm5t4cptSve/GJ4bc/b01P3P313v8ETwNu7agxNUVVI0PJKR6Yqyhfu3VS03PqI74v3dYYCWiSgu5QqhHzr8d6vPdRdtByZSLu6wd38r1++KGxS6uKB33t2x8Et9R71JEnuaY1s31Tzv/zl4f7xjKYqHpxL9Mm72kemM7/7pR3t9UHL9bZ31bY1hP6v/+mDp+5u/wdf2AbyIiZt64rpqvJXL/VXH/bSwcMUsbs1+m++e6AmrFMmbWmvqY/6dRAIcfH4kpnpVx/q+vbjvRATE2lnV9zQlL968YI4zoYa3z/7+q7Opojrsc6m8J7e+P/xkzM/eXNoc3vsiQNtYgraVNvuN9Sj/fMvfTTObO9AX0NPW+Snbw2BCMqld29vjIS0ybnc7z+7Q5YJv4i1hiL/xS/hIjIm6aryrcd7n76nAxaR+Jju6o1Tz/v14UnGwF/yc3e1hfyaR9nDe1vESb19Ytq0vOa64Lcf7/n5OyMT8zmiKx71uloi//P3DsTDBmXS5rboYwdb//z58z94bUABIR+Uxz5zT4fjent74t97ekuh5BBCtrbHsgXngzOzmHRHEARB7ijulMBdyHY1VZ5JFLNFpynuN3TZdSFJ7DN4eMjlwrt744e2N7x+bOrw+bmGGv83H+sVLhcupXUx/2883iMr5OfvjE0s5JtqAr/xeK+qgGTcY/TZuzbdtbXho7Oz752eC/nVLz+46fEDra8dmXj/zGyu6EzMFfb31WuqbDueosgeBae8ze3R2VSxYLlFy31oT8uDe1rGZ3O/eH9MU+VvPbH5ybvbPzgzNzmf53JeqTbi+84Tm02L/ui14fl0yeW6cGFfo6nybLJYKNm7uuPS8sTAa6kPtTaEhqay4EliOV9+oOveHU1DUxluZK4+daj9sf2trx4ef+vEtMz16D5d0Xi2voIiBqeiRZakaFD/xqPdiiL/7K3hifl8wXTlNa0xZUI6m8K/9bm+yfnCK0cnu5sjTx3qeOxA6wvvj07M5f0+xTLdL9y3aVNz+K1j0x+ene1tj33loa6nDnUMTGSzBevkYOJzhzoeP9j+F784pylKLKQ/dqDt3EhqdDZPmfQ3L198YE+z31B/9cEYIeC1AgIkXh5QgU9a1G8+0lMX8//qg9Ezw8lD2xvv29VUE9bH5/PibBRZ9ih9/ECb31DePjmzmCpNzueJRLpbYRlkbDb3yw/HGKXffLTnmXs73jg2NbVQ8KB5UPCRvS3HBhbeOT5tu94Td7Xv7K597ED7+dG0qMgkRIpHje89s8Vz6V+91O/T1a8/0r2zO/4bj/V+/t5N/ePpt09MdzVHv3h/xyP7W3/5wVg6bymyvMJUB6pFpa88uGlTc+jFD8ZPDC7u3FR7cFuDLEv9YyDLkbgKqKcl8sw9HQvp0o/fHJEk9syhzq890v3a0cmx2VzJch/e27qlo+bXH4+fGkq0N4S+cF8n15GTk4OLfl154q62uWTp/dOzmqrMJvN8rgh9hY1lu0mYHXQ1R773zNaRmfwbxya7WyPP3NXxxN2tP3t3eDFtSpJk6MpTd3cUis6LH43Pp0t3bW14eF/L5+/rfBNGhqZy9g9fG7x/Z9OmlsgL740VTYcQaSFtqircTX5DFRNOUcH8jUe62+tDL300dmYo2d4Yevahrmcf7Hrr5NRcoqTyRSVFlh7d1yJJ0mtHp84MJx/e03xwW+Pn7mr/4PQNaEeFIAiCIBuIOyhwF1qOXNGxHRoOagFDzUD7dVY0XQ+S0BCn7u6Jz6VKP3xt4NxoKhbSs0XnzHBSUYjn0qcPtfe0RP7rry786oPxxbRZA+ph+9xIkmemQ195qOvsSPIvfnH+4kTG0JVUzvynX9/9hfs6zo4kF9KlE4OLv/lkXyyszyZKCu8wXxMytm2q+eDsXDpnxYLG5+5uJ0T6/kv9752ehfpXj/7Tr+/a1RMfns7KMqSxJUmKhX1//sLZ4wMJz6OuC/pgkftUFXkxYw5OZu7Z0VQTMXJFVyPEcmhzbaChxv83L/W7Lm2qDXz+3s65RPE///zcqcFFXVOnFwv/6tt7vvJw19H+hVzRYUwqWq7tetXD5Xp8cMqNNiWLW47Egsb3X7747slp26GW48pLOhkBBNO2EwxoIZ/2p8+dPTm42BwPmLb3nSd7N7dFJ+Zyjku7msOPHWjrH0v/1Uv9I9OZmvMLNSH94T0tP3hlMJu33j058+yDXY/sb/35OyOzidIz97THI74//uHJounMJgo/fH2wryMaCxk/eXOoLFCBQtuqukxJsh3vnp1Nd29vfP3o5Pdf6p9NFk8NJX//K9vbG1qqG2wls1ZfR/QX74/+/etDhYJTsr2AoXzxvk0KIT94beCNY1OSxCyL/otv7T60vfG/vzpgqEq2YP/68PgL742eH0l71JtJFv/Z13fdu7Ppv/7yPC9UBV9Fn6bURf1/8Ytzbx6fCftV03K/9nD3b31uSypr/sUvzp8fTTXWBlRVemhvy/ZNtW8enwoY8rKLoiwVS+6evvjjB9reOTn91y/1j8/lj15YYET60n2dZ4aTSyXUoPOJBPR/96NTvz48SSnN5p1/89v77treMDqTk2VpT2/dxHz+v78yMDabq4/5ZhLFixNpv6GeGUrMJ4v37Gwcm8395M0hmK5J0FSYEFBSlSy3chFzRScW0hfT2p8+d+bMUKKpLsCo9Pn7OrZ11LyZnFIV2fPY+2dnj11Y+PDcXL7oXBhNB33a3r66NpgrZjJ566dvDcejvtaG0C/fH11IlzQVSoo1Be7tPBi7wypT0fL29dU9vA8mkN9/8cL0YrEmbNiu95tP9j1xsP2vX+oXXVzzJWdTc+SNY1P/9ZfnFzPm6HTW0NU9m+PxqA8aHmP7VQRBEOSO4XZ2lVmFyPCZlmfarioTv65xo8CyTwhEFaocDepD05nzoylGpUze+cGrAyPTOVkGJczThzqGprI/en1oMW3qmpIp2H/3ysDQVMbz2K7u+Oa22E/eGjo5mFAU0Hm//PHEx+fn79/V0ljjL5TcSS6e7mqJCOsSLgI2OpvCQ5PpXMHuaAzftbXh9ODiG8emKDeWef7dUQgr22OqIgsrPJ4Ynn7xo/FM3sqbzuqiRiaNz+cVhfS0RF2XipLVlrpAOKCPzuSKlruzK76lI/brj2EFQFVkx/HePD79+rGpu7c1ttQFRWjOTULW8X6p/E0UXx65sPCzt4cXM2bBckTMtwohy3n92NS7p6Y1VR6YzLz40VjRgrpSTZOLpnv3tobGmsAbx6ZODC76DHVyPvf8u6ORgN7WENJ1eTFd+ujsXEdD6MCWek0lz9zbMTCVPjmYCAU0cOzhVjaM67Ad1yvPKlYcM6yBPH6g1aPs5++ODE5lDU29MJ768ZvDuSIoakRtJZOgODiVNX/46uDgZCZbcoqWGw3pTxxsO3Zx4a3jMC3xPOmXH46Pzeb3b6lnUDtLRmez/+7Hpz48PWu54LX42pHJgclMXcxXGzGEgJ4xKRY2Pjg98/JHE55LE1kL9luy2xuCrx6e+PjcnCxLQ9OZ598DwX1fe9R2ysXElYN3PO/+Xc2RkPHTN4cvjqc1lYzMZH/8xtBixhTWK5SySFB7aG/L4FT2xQ/HHO4b88bxqWP9C/dsb1RlELEYujK5kD89nJQJWUibP3pjaHw2r6uw1OPwqQtloIdxuTFO+aqttJuUZaLK8mtHJ98/PaOq8sBE5qWPJzJ5e2tHDJRiBG7yP/3ZmV9+MJaBRQMweTx8YZ4QqbslIq4JjFC5opfCvoRIiM86VHA3gl1Ylvfo/lZNkf/+9cHRmZyuK/Op0vPvjo7O5j53d7vGpU2Mr5/kS85P3hoencmqCnnzOCyI+Qy1rSHsrrQrRRAEQZDbmzsocBfpWI/SgunIMtF1SAFWHpIJ2Oel8lZt2ABLFgo2LKosyzJkcLtbI9GQfuziYipvqeBjyN3xeBSoyKS+xl+y3NNDCVADM6YokNc/fH4+HvEFwdNGHpvJzqdKe3rruEkK7K6rOeK5bHQm51EWDqpN8eCxgQUe8YCo13a8c6Op1vog2FaWLQXl4wML/BzWejZKmioPTmYoY71tURdeAJr13tbo9EIhkbEoZXUxn19X3zszqylgUwi5YdM5M5R0XNpSH7iabjYVQ5jBqXSuaGuKXOlXJa11dHHpmZEk5GUpTIcyeXtmsVgb8clEdmGPIUKkU0OLhq64HlVB6lOaXix0t0QolXRNeeXIpEfZPdsb79vd2N4YeffUjPC64d15lo9H/Kw5TqYp8ub22FyyeG445ddVx/X8unJ6eHEhBXlf8RJGJUNTBqeyiYzJA0QgFjGiIZi5pbJQjSpJUqHkjM/l6qK+IHcWopTlC46qKrbjce9CaWaxCMF60BDRKuxdlfsnMkXTlWUYrkLJWcyYuZIzOpuDLYA6XB6fy3uURYM6TOSqXBE9j0VDRntDKJExzwwnVR5q66r8/2fvP4Djuq58b/TkzrkbjZxBEARBMGcxSZRESbQkeyxLjjOe8diTbt25c7/36ptX39SruXdqPOFev5m6kzRjeyzLVrASKTFIFMUk5ggQIHKOjUbndLpPenV6kUctgAQhiRKFxvqVSwY7nD5n7919/nvttf9rzB/vGY3oWFohFFg/MXD0wEQ0ElcT8WmKCoRTI754dbGVpulUWkrxos2oU7011b6mshlQ6rx1Pg0I+U7qGE4J/eNRklSHtI6hJ6YT8ZTgyE5R1C+LrMSTgpoqJim8ILEMPeaP82nJbs7OYci7fBBMlfUc5bHpfaFU90iEZWlRlHUcPeKLdQ2FvU5Ddn+COjY5Ws1wG5mKcwwjSQrHUkOTMVGU7WZOLSxw17GLIAiCIPnC4kqV0TLdIeKYe8vPOkyLo1Pxr++sefahuqOXRgcnojRNWU1cPCUWuU0MTXWPhBmKVDNnsm7TbDYczrGU26Yfm07GEgLHZP2yVR9qcnQqHk8JTqter6MHJ2PT4dQKVbjf9F5sqnaOTsV9wSTDUBYTR1LERCDpdZmyHttqkDIU5V1WG3iWwxn6QkmGpiAlOlcGqWKRVQPbskLUlNgkWdWXJgO7pNzeNRJO8KrjisOiS2XEiUBSxzJaUHx8OhGMpL1O1VdxPmQTKuRgRLXfyXrR3P59WSdKedQX03PqZ6mBXlGOJjJ2M6fa5NOkw6x6FMZSQrnXQpGEQ1aMBiYUT9vNqjclx1LDvtj5G741Sz1uh0EQpRNXJ0BGQzKJ9setnaa5n61uzbSaObOe7RuPhuNpu0UnSrKOpVNqIpCszVMVQmEYcjqcyoiSjslKbEIpdBjjWZ3tdRotWVVtNrKxZIakzEYDk0iJsHmguthSVWyjKeJCx1TXSFgQJGv2xWrFAIpMpMSpUCo75SNpgpQpOZ4UAhF+OpIGux6OoeJJ1eHdZGA/8tHMnr0ky1YT57Tohn3xZFpkGfV8WUbNS0nyotXEZr1rFLdNLyvKyFS8KDu1Ux3r1XUeiWVU10VJVsb88fXLvN/bU3+qZWJwMmrgGD1HS6q3+scaUJ1agEv6zC+Jei3xlDAZSBp0DKEQHEcneSGTkSwmTu327B7ZjCC77fqlFQ6zge0ZCfePx+IpwWpWX0DO+iDtn7c6Su0pm1VnNrDDvlhGlI16Rs5O80RJGfLFFFlxWfXDqRidjdAHonw4llZbTJX7as6SJMvaycys94sgCIIgecriEu6KKoNok56VZSKZjbvnPktRZMdwaDKY/PYjS9x2/YV2X89oJBRLy7JsM+lYhvKHVUEGSjpbv0Ytb6TnmCKX0XfLJhyepNX8XTEY40s9quIPxdJj0+r+VIdVl/UupFbUuAYmolNh3qhjCuwGQZA3LS9qqnFn0yHUakpNNS49R+s5RjUHVF3VFUmCOkQzg5dqfJQipyN8MMoXuY1mIyuIcoGDqy2x/er97nhKMBtYt90QiqkW3RDilbOZ8dFEJp4Sit3mecoeklRdL6F40800iDsgykqCV81qFEXdgyiqJ6/odaobusXIWYwsw5B7t1ZxqmJWg99M1oRxfDqhyvGsqjt0bri5xrW2vuDt0wNDk9GsecjNZr951beLFqsmmDKhzhBIIhxPE7cmF7Iat6ZVC5cZ55mtlsVmh4GiECVuc0aUVy3xlHrMDE0ppBrebqxyWYysxcjGVLFINlQ6Ht9UsaLWzTFUQ6UjnhSyk7eb2zppioqnMuBtD2kehKJeO59RE7TU/QDZOkTZRZGP3qUhy4qOpa0mrmskki1QdbP4FMvRarg9K5glWfbYVZOZpRUOt82QjeuTaUFqrHQaONWpnWOoy93+HWtKfm/vMq/TcKnT3zsamY6k9Bwjzm7AO8SrVWceUYqrFi43L0QQ1WpcMBmDpvM6DI9vqdiwrNBl03UOhS7c8GcnhDdT9mdH3GektIiSbDfrbGZd71iEpinINZJkhWGoYJTPCHKxxzQwEaOzLknQgCYDoyVKkdnJJ1rKIAiCIIuKRSTcQQOZs7krGUHiM9JNY5YsapTayPaNRl58t/t7e+of3VC+c1XJwbNDvz7SHY6p1ooUpcYgP17SE+ooUU6rfiqYUg3jQUffDE5LGUF22nRQ6f3GYGjd0oKlFY5TLRNFbmNJgflU60QsmXGYdQ6LXpLlLU2FucVWGZqeCMRZJhtOzOYVKHNmBciy0jEYWlHrKvGYeobDxW6j1cT1j0XVCjg2vc2sFgDSioNCrnEqLQqS7Lbps6pqHg2YfRGUxZkbSa0bBaLwZgKJanlJqhMSm5kz6BmjjnlsQ3luoU2OUQVf1qNG/aCOoZAvlHLa9CevTaj5NvMLq5JqNojMZV0kVd/AbHLIzfaZtUCQzZtSi3oS9M2jO6w6jqHW1Hu0xoCOmAoldKzq9mgxMc8+VLd9ZVE8KSgE8dimimRW2moNe7P4K6TN3GpqtWiorMx48GbCdzbSr50POHty6k4AAcqyaqcBEyWoWWsz6/QcvXqJ++N7EtTxqecYjqWu9Qb2nRp4dlfd3i2Vu9eVv3687+X3uz9RWBr0Ogxp6Mns/u2PjcCH1pV9+5GlSV7Iuot668vtZoO6D+HjdW/v+AFS9stoNrLxlDrH0+YQJKGaBREk4bTo1DGf3ZUAU51sh6qvzDqaZtPGEARBEGQxsYiEu3qfV9TYOcfSgSivlkFlsgHeLKooIQlRVD64MhqMph9cW7x9ZcnerVXDvvjLR3tgax2nJhnfRt9IosyyamqEIkJZy+xTNy0mVYnBslTbgLpvtaHS+e6FkaUVjowg9Y5F1IxzRd1wyQvSgTNDkXiGvrV7UlaUaDITS6mJLvPJQSdJsn0guHNNSbHL1DkQWlbp8IWTaiqOms+jSJLMMhRNkULuW7KZEkLWsubWls2cZ+8Q1f7U3NR/WQE4EUweOD2k6U5IHx/xx0kVtVUZirSb1Sxtq5mjSNUnfj6pzHCyUG42m0Tx0fHvLiZVnaqkMuL7l8b8wZQacYdovULEU5lIMqMQxMo6z9YVhf1j0TdODIz61ZzyxzZXzD/XaD6oKj977nc6JEmodpCipLx7fng6nL45YLL58RlBjiczNKVuJDh0dtgXSO5cU7JtZclXt1WP+OLvXxrR3YqXfyayn1Xg0H9te3U0kX7jRN/1vqDbpn9wbdmapZ45V2JmXojaU7I69dU6B/6A/QyCOGtQIgiCIMjiZhEJdzV9hZcqvGaXVX+pc2q2FIS4bzSROXFtbDKY6BqO/M5jS7esKHzxve5kShBExaRnc2N8UHk+I0iBWNpu1oHauHkogmAYNXTqD6UkRc3TGJ6MJVJidbFVUZQVNa54SugeCRt1DC9I/nDKpGOPXh4bGI8YblatV828CUI9uLo9dh5QJNE9ErYY2EK1qpG8ss494otPBlMGjk7wYjiWWVGrhyqVGjqGpijCH07dSocg2FsxXkh91rEMc6t65T1AURPcI4lMKuu/+eqxXgOnJs/ANIdWjQJvBpX5jLR1RRGkMu9eW3r86vg81wQgaygSz4iSuj1XgjUQSJHKmubM/fbpcEqWlAvtvksdU0Y9C8sGavSeIPiMapXYVO0SRPmVD3rfvzgaiqevdU87rbonH6i6V/KSotQPiiYFvS5rvHILGixfsp9BU2Q4luYz0qXOqStdAahApChqdhaZNXvJ9iwViPAfXB4bm070jUV/57GGlXXud88P36t9nJIsVxRZvU7jLw53vnliYCKQZBkqLcjLqhzZVaN5NQZNEQleiCcFi5rr/xGyrJrEE4raHfMb+wiCIAiyWMh/4X4zAk6qRZREUVld77GauZbe6dtKUkGUdQxN02TPiGoKubzaWVZgNnCq+aOi1t8xZkSZy5pdQNKCml4sqsp7abmdUcPnNxNKJEkx6RibmQPXEZIk40mxfyxa5Fa91asKLaF4emI6oaYWpKXpMG82MAaduv+Pypp4QMRd3Zj48YpIdyQbXPYFU7GEUOIxm41sZbHlSqc/EOGtRjaSyoRiGZuJM+iYdFqiaVXlC4JsVlO3ufHpOEWS6YyaAmPQM6KsGhSqpoqS+gLYHXuvtv9RJJnghWgy02h1Eoqq27Sgu2oPkg23S5Ji1Kv1oYYmY1Oh1M7VJXWltvb+oF5H3z3+n7X0CUR5QZCcFv2tD1WT7A0cm7WUuf0EIFuLlJyYTliMnNmgbkiFLcjZQ6qBX9DRZV7z0ETsbJuPIIhSj9kfTk0GkvfKjTDrHaSmu4Si6SKnIZtMoy7byGq6DmUyMKm0OihoWt1TK2UrgkUSaauRyx0wUEsrLcp6tcgRcWMg1DsaWbu0oNBhAD/Ne3Gy6henotDiD6fOtfsC0XSx2xRLCqP+m7Wc5jNU1JlGdhYXTwlFLlNux0qy7LBw2bJiCXW56R6cMIIgCILkCXke0VLtXbL/oylKEORSr2n1kgJ/OHVjMKT6onz8xdkI+s2kZJ1ajF3pH4sadazHYfCHU6KsNNe5wDyEzB5V/W+2OtJUMFnutRQ4jaRCaI+XecxGPTsZToGqJkniao/fbdOvqS+wmbme4bCkFjtSZVY8JUQSmWWVDpZRdyuCbs7xT59vpJnPSDeGgpVe8/JqF8fQAxNqtSP1MAoRiqlh9YZKB+SRUxQpKmrdKJdNP+qP0zQVV5cUJHvWChPENMfRTqtuRn2lzwIch1RUZ3GGJpeW26F2Elyv+pnkTSvJ5lp3RaHl/A3fb471pQX5sY3lkiypL1NtHBVBdZBUI9DaqX6sE0m1HcLxTIHD4LLps6FoSlENMQ0GjoYdkLc9O4pSE3h0HF1RZGHU5I3sGQG3XuS2GURJ9T5XfT+zaR5FHhPHqIskn10QZ+2GqBQvBiN8VYnVoKfB7FxWFJOBcVr1kqyOGDpbb0uSlIZKJ4zwW3odWujWXoRstk3WcFPd/OB2GOwWnZT1VhdF1THzTg14VyCHypXdmCGIMsuoTSGKasEvdQlFXda5+fmiJKtrBdm1jpnjWZ2BULGEEE5k6spsVpPqOJQdDKSOoyuLrJJCTEfT6tXh/lMEQRAEWQzCXZaVSDwdiqVD0fREQA1vP7e7bnm188SVMX8opeUeACRBpkW5wGm0qQUjeSHrYGjQqVv9CILsG4v4gsnl1c66MpsvlExnRH8kZTKoDh6CIE+GkpIs71xVksqIsZQQiqU5ltq+unhkKh7NlqcBaXW9P2AxsrtWlxgNbEtvQDU5UdSY+nSEH5tO7F5X5rDog9ksiEg8zTKUxcgJ0scK9MxBNmlHvjEYqiyyrF9akODF/vEoJLhzDDXqj6cz0s5VxZIsR5OZUCxNU9TGxsJ0RhrzJ9WtnLzIZySv02A3c+FY2h9JFTqNa5cWZARVMd8rYC9vz2hYx9APrSsTRCWWEFJpMZJQc42Ym9n85LaVRYRCnGwZbx8IdI2E1iz1VBRZs2sFZEaU02nRYdHHeSGeEmKpzOykaoidl3hMjVXObKEoMRBLr6pzuW161Rfmjj4qRDSRGZ1KbG0qLHWbA1GeF9SOYCjKbOCgDFaSF6wmnVHPxBKZYDRtNXGrat0w2bsnZD1J1VmHy6JftcQTiPAJXgjH0/UVzhKPSVA3xKoztMlgMhJPr6pz15bY/JGUIMiBGK9jadD6CV7NyGJZKhRXx1I0kQG3SiJrKKQ6S6ZF1ZEzlYmnMgl1a+knO8ns6gSRTAtWE2cz60JR9SCpjLiuocBqYtWKSNnmVD3vk4LdqlZCjSXU3RpCTrkuOIggSmP+uN2s29joDUTUbSf+cKrYbVq9xNM9HBbU6lTo0o4gCIIg+Z4qA4YhHEs3VbsiiQzHMCYDvaLG9bXtNaP++MFzwxDXvunqeKt0jo6j9m6pFEX5/YsjMkHUlFrX1HuC0XSSF/i0eKHD9709S39rRw1DURlRYhhq1+qS4cn44fPDXcORtv7gIxvKrvcHhybVmjUbGgtW1LhfO94XT2aYbAFISGUJRNLNdS5RkrtHw6qqzhpXByL8qZaJb+1e8tS2qg8uj6q+4xy9dUWRP5Q6fH745v7XO4aKb0JRpCCJgxMxq1m3YZk3kRL61KKhlCTLOo7pG4u29Qe3NBU+uqH8xmCQJMmmGteGZd4T18bB45JXpO6RyOObyx/dUH62zafT0Y+sL3Nb9eHEzYmH1lbzSFdRQ9EzHlTtW7IOLhxL3RgIdg6Fd60pvdYz3TMaIQnFYdXvWFn83sWRlt5AudeypanoYsfUsC9OKMQHl0b/9NnmdUsLXh3rNRqYtCCFYhm3Xb9peeGIL65naV8oJYiqQZB2kixDXbgxtWtt6d4tFUF1F7K0aol70/LCm1432il93GiGoqhURnzvwsj39iz52s6aA2cGBVHRsdSGZd5URnzr5ABBEN3DoWcerNu+qvhUyzhJkjtXlxQ4DKpn4kfXfhujTPm2DZLdQTu76Riaau0LRBPCU1urJqeTcV5otrkeWlua4tXkdVW4q/MH8fi18d95bOkzu2rfPDWQEUSaJjc1FvGC+M6HQyY9+5UHqsanE2euT0qybDPr1i71dA6Hw7G0jlOXVoJRfkWNa019QSDCMww5FeLFrEtL7knOfc4kRfSNRS1GbnNT4eBElCCIzU225dVOPiNpyfqSLAciaaOe2bi8kCZJg54Nx9OJlLrHN+sQo+aycyx9od33yPryp7epJxyOpzmG3ru10m7hfnagg7xzW8FuZozFIwiCIIuNPBXu2TQHr13/O483qGaCNFXqNevVjafpl470dA9HOHWXaTYnmCIYtViOKiZMera5xllX5qgvt49OxVfUucoLza9+0CfLikHHnLw2vmt16SMbyisKrd0jocoi6+olnndOD55smRgcj713YeQHX1n2J7/VdKlzysAxG5d7x6cT750bTmUkg06tLEOpW2PFtgFV31/umJoO8VnPcrUIJS9Ih88NbWr0Pre7rq7UNhFIlnlNW1cU/eZY33sXRwhFPUnV8vyuV00QE9OJZEqsr7Bf652eCCT12eQQhlKzUw6eG26odPzoqcZzN3wsTa1e4k4L0psn+vmMZNSpSwenWiZ2ry/99iP1VUW2AqehpsR6udu/rNIBE4/ctpobiqKYWWer+t9nbVoYmpoIpt482fd/fXP1H3216XK3n0+Ly6td9RW2lr6AKE3vWFXsthsOnB0mFUKno09dm/jtx5fuWFXyweUx1cGTIHrHIoIg/clXmy53TXMc9fMDHYGIyN5KfMpqX/Js+2RLz/SWpiKzkesbjW5oLJgKpcam48ZsOaGbpwR1cW++S10SSQvyuxeGNq8ofHp7VZnXPOqLl3nN6xsKPmydeP14P0tTl7v8T++oee7BOrV0FEVsaSrqGAyp4e2sl6XWRDOixMxtG4ShmFlNqXqS6pkLHb6z7ZPbm4v/y9dXdI2Em2uciqLaiVqMLEw1aIp858zg1hXFj2woKy0w946Fy72WlXXulp7pfScHPXZ9fbl9z8byZZXOYFQt+2W36Nr7gwledFh04XimZyT80NqyHz3Z2Dcei/OZl4/0CKI44yTnOmfV2ZPsHYkMTER3ry21m7kxf2LHqpLBiajZyBk45mZOFEmOTScm/Mnf2bN0SYldr6PePDkw7IvRFMllm0hRSykxl7v8Z65PPLqh/L9+o/l6X6DIZVrX4LncOXW6dQJyfpTbtRVFzGsoIgiCIEiekae3PpIw6GiPw9Bc516/tGBFjZNjqO7R8P95/fqRS6Pa/V7VBDRlM3GqvUrW+futk4NgabJnU8XKWnffWPTQ2SG1BCZN9o5G//3tG6Ikr2soeGJT5ZamwkCEP906Ictq5fb3L4+ebBn32PWPb6rYsboknsy8dryvfyKarRGjKhkmW5qnZyRS6DZ1DYfTt9IAVLNIhhyciL12rC8Y4Tc3FT6xpWJLU5E/nLrQ7lONq1WvG9piyaab3znEmD0O5Y/wU5GUjqV7RiKSLOc+dfb6xJGLI2YDu2dD+YNrSgiKePWD3s5hNWtF3f7IUNf7AkcvjZYXmh/dWP5Ac9HV7ul3zw/ZzWrjwMdCW7GqT+Jcp2HQ0TYT97HeIAmTgTUZ1Fmiqt0p8lz71IEzg0Y9s3tt6Z6N5curHdd6pjuHQqUe01PbqvvHojcGglQ2MToY49+7MPLgutLV9R61BI+evdzlv94XXFph/8rWirX1BTez8HPEMmzxfOVobyQhrFnqeWpbldOqf+n9nulw2qYmjdw8JauRM+joj6XxMNSwL/7q0d6pIL+xoWDvlsqtK4piKfHEtYlsrjbZNhA6emmk1Gt6dEP53i2VvePRd84Omg2sjrnpE8ox6rVnrSQ/Oh+jnjEb2NysD4UgrCbOqAcHoZzWu5lAIr9+vH88kFhd73nqgaoyr/VXR7rHp5PZNHc15YWmyWAk/eJ7XVPh1Ko611e2VD3QXCRKyrErY2qLRfkDZwZlmdixqvjRDRWN1c6W3sAHl8d0HKMuQzHUmbbJwYnYqnq1ZRoqHNB4Rj1jMd50d1GUm/+ckahiznYiLAv4I/zrx/v1HLOtufi3dlSzNPmrd7sVhbAYWVjK0Ovo/vHoqdaJ0gLznk3l21YWG3SMJKlD0WjRZSvv3uy1N072tw8Ga0tsX9lauW6pZ2A89ptjfeF4Rht46r5qvWpApLUSlDTGAkwIgiDIYiMPI+7Z3BLl/Usjw5MxQZIptdSLHIplJgKJ632BVFoy6VUFo5qF0+TgZOyf32jrG43qWTojyKdaJyiarC+z28xcOJ6+3OkfnYpTWWsXUZJPX5/Qc3R1sdVh0QVj6faBYGtfAPzdA1H+N8f6OgfDdeW2SDzdMRC61huAzX83K61mQ9EXO3x//+LV41fHVPvtLOBYIhHK6daJSCLTUOkocBhC0fSNwewRCHV/YcdQ6O9fvBpNZFTj+TuRTREJRvlzbZPVhZau4VA2SHnzo1maiqWEt04N9I5GGyodCT7TPRK53OlXc3VYNQ+eIohURnzzZH84nil0GqfD/AeXRyYCyZ+90znii0MQ+WZbjcNs5DanIKuqnTlxdXzcn7i17qH+VxCVN070qW2unUwi89bJgd6xaH25XcfRvkDycpd/KphyWHUHzgwOT8ZTabXOKMwWDp8bVpViKEWRqnoORvmX3+8ZnopbjUzXSCSZEmd7j7CMmnDyL2+2La20G3Vsx2Dwave02dBv1DE6Tk0EF0TlP965MeyLa4lAN7d4UuTZtkk+Iy4psxe7jKF4unMofL7dx2RtZZK88Prx/ulIushpjMTTJ1om+sYivzjc1TceVe0mSaJ9IPjPb7b5gklwaYRZxOHzw1YTq1ZOvSWEWZr6j/03psK8uhrz8VPPunDSXUOhf9t3o6nWZTFwPSPhs22TiZTYORSC4Q3NcrFjilCI2hJraYE5mlA79PT1SYoi0oJ8/Oq4LBO1ZTaLgQvG+LNtvolAgsvWkGIYanQq8dN3bqxZ6jFwzMXOKdjBfPj88IUOHaTH6Dj68Plh7albXyvypSM9GUHNvFKXihTl+JVxhqaqiy0ZQW7tC7QNBH99pDsQ4bMJWuoebj4tvv3hQCIleOz68enEuGraw/aPR//3L69Mh3mOVVPFdJyq71841NVQMVVeaBnzxzsGI9f7gyxE5bOf+29vtY/6E2rB4+xEh6HJyUDy3/ffaO276YaJIAiCIIsEsv6pnxD5SIIX06r3tpoSQxIkQ5NqqE/PZHX8R7UqM6IcTwkmA6uWas8+HE1mLAa2wGH0h1NJXjQbVLkAqk5W1N2uVqPO49BPBlOpjKhZUFOUaqGdzkiFLmMkkU7xksWoFvDMzc0F0/dIImPN2izm6g2YXcSSgl7PFDoN/iCfTKsfDXY0fEaKJwWHFqe8AwytCvcnt1b/6bMr/vB/nRiciKkpHLdeT1Gq52OCFwtdRs0/G3avaueQyqjWh0Uu05g/QZMKxzKRRNqkV2vNglfmjLaaDUmqCxdpQXJYdNqDSraGEUGQWkxXzUsRJVXSOQxGPTPuT1AkadQzoqRE4hkdR5sNaloI6FRBlEOxtCUbIJezOS1JXrCZdUYdPepPGHWMVmE05zTU/4ZjGadNT1PkVCip7mdNZWRZsZo4MK2PJNSMaqP+Y3NXGB7xVIZl6BK3cSrMZ8cAA/pV/eiMRJFEocs47o8rsmLQs5F4xqBndNlsmbQgJXnRYlRbTGuieEqQZSUbwP6oOGgolmay+49vm6lNkkQknrGYOD3H+IIJu1nHZ8SMIFtvLWXAzod4MkPRVKnHFIjwsaRgNrJZXxY17yueFGwWzmXV+0N8KiOas6pX+/QEL3jsBoIgpsIpo54lsycpSWpdWzh4LKn+UzV7yWnaaCJDkqTVxMKeDVFS0oJU7DJG4plwQq0BHE6oe3lNt/pOHVFpUa9jnBbd6LQ6RzKwTEpQ98s6zDrNj5UiSRgeHqdhKpgkFNJsYLJliW9+rrrbO9tWNzPsCUKQ5Ljqdq+aqKJwRxAEQRYPeSvcoXRmLmA7OOtl6itzPf/Atly1o84eYIZfXtZuXH1WU/OzDwXZ87k2grmvUcPbt3tOyZ7zzbKRH/9oeFdubHg2ZDZ/IJ7K/Nmzq7Y0F37nL98XBNVs8bYXCx/1MadD7QXZtHutEdTrvXUes9tqjpaf8dFzNBdJftTm0MLgCzlHo4H5DLxxDkND8IaH14OvYu45aF05/464YxPdOje4qNtc++wGmXWZM0/+VmkqOODtR2PueYLru3YJt67u1vxn5hvVBPLs2hS8acZJzuectabQzi23H2f3FDTSbQfzTUV+62xnf+lmDombF4iuMwiCIMjiIg9TZQA1aX3GTT2rGGa9jCBJddek9gyYvYAipG8JdA11p6asSFCokvjYs+BCLUk3a1jexjQENi+SapB79nOqczilnomaZpA9gmbrAe+ay1iGJAVB8oVSRW7jmnp3S0+Az0iz9z7CxapCk1CvbfbcBoSarJ6A+l41mzl7vcod2mqOlp/hSQIn8/Hmunky2az3j55V90R+vKdmNxosZcAbb9fMtz6UUY8P3ufZTbofOwfYdDv7YlT7T4pSiGxHZLVh7hVDRVtpRhPdesXNJvr4OamfO7tBZl3mzJOnbx4HTl5t1Y83IBw5a9Ki5oOpqzFaTxEEmb12rezA7DeqBbeyzvHaHozck5zPOWdfog5LklRt9aGFtWnPrdeox88qdTVxKzuju81ghq5RM3lmjZPbD4nsBd51KCIIgiBInpG3wn2eN/XZ0i2ra1VBQ2QFx4zXa89mD6/cLtJ8m2PmfpwqmOY8EzCYz/3oOd4FKwkZUaotsa4266qLrcUe088OdkHMe+bex5tB7uwc5nbTgJvxzlti7maw885tdYcLuc2rbmd9ePNkIBz70Stnndjsy5dv98bZQExdO+aMF9+pGJMmPW87Bm5lrn+CJoLo9exzm+PMtZGmTYFuO5zl3PPMPY1bEXeavMMwVuel6jLNR1fx8ZOczznfjLhTd2xhOG3t+zLHYL65dEDdvkNvMySyFzj7lQiCIAiS3+StcP8sgFD6lM9+ZjnxSY+g5otnpHUNBd94sI4kyaHJeMdgcI56p/MxYie+KD71R83zjZ/lUuZohy+mibIjbR4vu/NUcI7336sruPtwmveHYfgcQRAEQeYmT+0gFxmk6qNCF7tMNE2+darfH06x6v5R1EEIgiAIgiD5A0bcFzyyWvOVPn/Dx2ekWCpzvt2X3aeI8UsEQRAEQZC8AoX7gkfJOrjfGAxe7vLTFGlWTR7nco1EEARBEARBFiIo3PMBRSH0HKNjVfdrcNxDEARBEARB8gwU7nkCmTW6vuk/cr9PBkEQBEEQBLnnoHDPE8Cb736fBYIgCIIgCPJ5ga4yCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBgiPyFJAiKkklCud8ngiAIgiAIgnzuKAopKfkclc5b4U4ShEwQvMDJCkko5P0+HQRBEARBEOTzhaZkjhaJ/CVvhTtod5qUSYIiSAy6IwiCIAiC5DkUKZOkouRvxDY/hTtNybzAmrjMN5ZdrnZMUyjcEQRBEARB8hpFIdr8xS+1rzMwGZaSpXyU73ko3ElSESSaoaSv1LV+pb61whakUbgjCIIgCILkNYpC1Dqnk4Lug8ElGYlmaCn/Qu/5KNwJghfZrWV932s+T5DKVNKK+1MRBEEQBEHyG4UgC0yx/7r+g0DKeHqkhqWl/NN/+SbcSYIQZcrC8d9ZcZ6jxYzM0JTqLnO/zwtBEARBEAT5PFFkhSB0jPTdpvOtvhJBpmlSyTPtnm/CnSAISab21rU1uCdTEksoMiUFCDmTlfR51ncIgiAIgiAIcdNNkDZLjC0pSMsKJh+p7ni9a6WJEfJM/OWhcCdJ4uHqDjnr4kmRFGFeTtDmrDkkgiAIgiAIko+QFJH2UfyoQhtFmXq09sa7A8skGXPcv8SQBCEpanqTxxTLblIVCVMdUfqHhHkpoQjZ5xEEQRAEQZA8QyEoPeF7kxj5ZzXFQiGLLZGlTt9VX4mOEfNpi2p+CXdS4QVuS1mfVZcSFZYUg0TB04R1BUGx9/vUEARBEARBkM8PinDvJmgDMfwvkpI2sZlGz/iFiQo9ISh5FLrNK+FOkYog0/VOn46REhma4pyEZYXaWRk/QdL3++wQBEEQBEGQzwdFJlgH4X6U8B9SYu00Q5VYw6JMUfmVLc3kn4UnS0sUSRJyirBvUydeUpqgdJgngyAIgiAIkreQBCFGVclnXkZErtCUwcAIqqdMfrmT5KFPIkPJJEkqUpowNxJsAWa3IwiCIAiCLApoM8G5FUUkSYKm8inUnr/C/RYyQRkIismreRaCIAiCIAhyRyiCyOfs6DwW7iShpAlFwnA7giAIgiDI4kAhCInIX/JYuMPVoWpHEARBEARZPJBE/pLfwh1BEARBEARB8gQU7giCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgCwAU7giCIAiCIAiyAGDu9wl86ZAUQlGyhbdI1cGfJAkqn438b4+SBf4msxD5fpn5faWLAVmW7/oa7GIEQRBkQYPC/SOyWp3QMyRNqXqdUAhZIURJEeXsPxcNJEnSNE1RlCZtZVnOFbh5A1wmKDm4zPmIP+TLCcdxdxXlkiRhFyMIgiALFxTuOSiqdpcVhZDJW8JdkbMPLh7dDgIdVCxJkkoOeRaq1K5L++f9PiPkM3HXHpyxwIIgCIIgCw4U7jcRZcLEqXkyx7ozXVNCMC5zDFnmoDdUccsLmUBSobJpM/mNLMtGozEajfb29k5PT6fTab1e7/F4amtrzWZzMpmEMPxCB9SbTqfz+XxDQ0OhUEiSJJPJVFxcXFlZSVGUKIp5NkvJYxRFoShKluWrV6/6fL47dZyiKDqdrrGx0ev1CoKA/YsgCIIsRFC4q8gKYWSJUFI50Zt+p41vHRf8MVnHkDVuZigkpZbrGwoZSSbkvM6ZURSFZVnQsolEgiAIlmUVRQmFQjdu3KiqqrLb7fmhaKks/f39ExMTmUyGJEmGYURRnJycTCaTtbW1BoMBtd1CAdLWR0dHQ6EQy7JzvFKSpKGhIbPZbDAYMGEGQRAEWYigcFehKUKQiSOd6X87nWAoosxOVzkZRSHSknKonR8JSf/vh8ylDjq/7/UURfE839nZGYvFGhsbi4qKdDodz/Pj4+Pt7e2ZTGbVqlUMw+RHskEwGOzu7tbr9cuWLXO5XAzDRKPRoaGh/v5+lmVra2tRtS8UKIpKJpPDw8N1dXXV1dV3UuQkSSaTyUuXLo2OjtbX10uShF2MIAiCLDhQuKvpMSaWPNOf+c3VlCgp22p0D9Xryp10MqNcHRX2Xedbx4SXLiX/ZIeFpb/ooDuo5LsqjHm+bO4jMAzT3d0tSdL69etNJhNN05Ik0TRdVFRkNpuvX7/e29vb2Nh411D0lzwbniTJTCZz9erVoqKimpoahmFIkpRlWa/X19TUuFyuq1evGgyG8vJySZLuySfObpD595csy/mRnvT5QVHU9PS0Xq8vLy+fe3BCF/f29tbU1Mx/iN7bLpixXQTG3p2O/9m/13Ofyed3cARBEORzYrELd0UhOJoMJeUD7Xz/tPj9TcaHl+rLHLTdSAmS4jRSxTb6Xz9MHLqR3lyte6CWS98unKcoSq7Io2n6Xt0OIcKdG0S87e0W3FFEUfwsqt3v94dCoYaGBo/HI2YBhcGyrMfjWbJkSXd3dyAQcDqdd0qYgXaAhGM4K+JLBlxpT08PRVHV1dU2m43nebhSiqIMBoPJZPL7/T09PQUFBRzH3XZ5Afo69+rAjoZhbvNt0vJwtI6DlKR5OthwHKcZoXzGiVnuEAXjICIvUBQlFos5HA6O46LR6Bwim2EYh8MBoXez2Twj6A7tDI9AMhU0lE6nEwTh053YbbtMr9fDNwi+2nMcf55f/0/H7IMjCIIgX34WvXAnCIYiro4KJ3vTGyq5r600VjjppKCkMuoN0mOhi230dFz+ybH4vuv86jKWpcnbakGTyQR3U1mWeZ6/J/kkJEnyPA/KT3uQpunZ5hiiKEqSNHeC710ZGhoqKCgoLS2Nx+NgkghXJIpiJpOpqKiYnp4eHh52Op13OgJN00ajUdPumUyG+JJB03QymRwbG2tqajKbzYlEAi4TrjSdTlMU1dDQMDk5OTY2VldXBxnwMw5iMplyr05RFI7jWJa9bb/DeOA4DpoUwqvJZJLOctcTTiaTLMtq7/0sF240GjUxKklSKpUi8gIQ3Hq9Pp1Ozz1nBp2q1+t5nrdarTNWVIxGI3zRZFkWRRHEtKIoiUSCZdlPoZUZhpnto8owTDgchjkhRVE0TcfjcZ1Od9sjpFIpmqZz89M++0jQgN8W2Mfy2Y+GIAiCfDEs6lV4JZvdnsgoJ3rSgkR8Z52xwEJFeFmSFTH7v7SoxDPKIw36zdXcxaFMx6TI0uSM2xzcR3meT2VJp9P35EYI84H+/v7x8fEZwd3c48PLgsFgS0uLKIqfYk1fURSapiORSCKRqK6u5nl+hvqB6Gw6na6uro5Go/F4HCYPsw8ly3I6nfb5fOFw+F7lmdxDINQ9MTFhs9kKCwuhuXKvlKIoaI26urqJiYk7yaNMJpMbIgUdfNt+J0kynU5fv34dFkOg71iWbWtrGxkZmUO4g6pLp9OXL18GM5/PqNWga2CIwigl8o75aGuIc9/2qUwmozWOtggDafGZTOZTfLMkSZrxWRRF+f3+M2fOhMPhnp6eQCCQTqcvXbrE8/yM48Og6urqCofDuV+3exUjp2l6aGhodHT0Tt9lBEEQ5MvJoo64KwqhY8jxiHhmIPNADbe8mKEpIplU9relro+JNgP56DL9mjLOwJKPLdNdGFSj8ltruLT4ka27LMsGg+HGjRuvvPIKhDArKyufeeYZMGDR7rIghSFdQYvqgUaE9frcl8EtXxRFvV5/9erVgoKC2tpabW19cnJSr9fb7XaIu0uSpNfr+/v7X3nllaVLl7IsC3IBDj4ftQEB4/HxcYvFAm4qt32ZLMtgxzE5OdnQ0JBMJnN1EujRYDD40ksvdXR0WK3WRx55ZOfOnSAQ4eog2AxqFc5cCzrmfgpMRWRZ1toKQviaEoK35OaraI05n+z2QCCg7bu9rdSTZbmwsHB4eDgUCtntdi2hAj5akqRf/epXpaWlDz74IHSxTqc7e/bsuXPnvv/97xuNRkEQtNNmGCaVSh07dqyhoUEQhGAwWFBQYDQaDx06VFNTU19fPyPpSGsWSJIJhUIvvvjif//v/12v14+Pj3s8Hp1OB82ojZMZc485zIJeffVVmC1kMpna2trf+Z3fYVlWFMXcftEC2Noj2kRRluXcslxwntoj0B3wRmgl6EetHbR3actHWl7KjBbI7S/i8wcSWmRZ3rdv34ULF2ia9nq9W7ZsWbt2LcMw4+PjL7744pIlS4xGI8y+YB4L4xP+1oYHNAI0nSAIExMTTqfTZDJpHyTL8ssvv9zf379s2bKzZ8+uXbtWkqQXX3yxurraarWmUikt3x1G+Pnz5zds2AD+lRD1j8VikUiksLAQwvAzeiH3orSTye0gaF6KojiOa2tr0+v1S5YsEUURFuvm+T1CEARB7iOLOuKeVQ1Ej18KJ5WH6nVWA5VMy+93pvdf5z/oTr/Xyb9+LdU3LUqysrqMq/XQbRNihFcoUg3Vz8gOb2trY1lWr9d3dXUdPnxYcwp3u91OpxPu9AzD2Gw20N96vd5sNiuKYrFY9Hq99jI4ptFo9Hg8drs9EAhEo1FNGVit1ra2tqmpKafTybKs2Wy22WxWq9Xtdq9fv55lWaPRaDAY7Ha7x+O5U4r2zEYgSVEUw+Gw2+2eo0INPO5yuUKh0Owcdwgtv/POO/39/UVFRQzDvPvuuzdu3GBZlmEYi8ViMpkKCgrMZrP2epvN5vF4jEZjbjQRssxB3kFbEQRhNpuhKKbdboeDKIpiNpu19xoMBnhwjssERZJIJHied7vdd9oPABpOp9NZLJapqanZiQSyLF+/fv3dd9/VRKckSRcuXLh27Vomk8k9E5PJpNfrBUEYGxuDRJpz5845HA5FUVauXFldXT17UQKapaCgwGKxSJJkMBg2bdrkdDolSbp06ZJOpzOZTBaLBUQbSZJWq/WuqQ4w30gkElevXoV5pl6v17KqzGYzfJz24txHYKAajUar1VpQUKDX67WWhDGm1+vh+GazWetiiqKcTqfH42Gy2Gw2ODi8S2s3vV4Pwjd3AIDqhWHzRUaCFUW5du1aOBw2Go3JZPLIkSPnz5+nKMpisWzZsoXjOL1ebzKZ7Ha71WqFfBuPx2Oz2bSZDMMwriyQ92I2m0+dOsWyLFhPwvSJJMnu7u5t27Z5vd6xsbF4PA7HNxgMMAMvKCiwWq1GoxHSsXw+nyAIBQUFDoeDoiidTpdMJi9cuOB2u0GRO51O6JfZq3BOp9Ptdut0OhgqJpPJaDS6XC74nSFJMpQFvptaX2vfUARBEOTLyaKOuJMkkRGV9gmhwEzVehiGJvoD0qtXU+GkXGqnZIU43Z8uttGVW00OE9VQyJzsy/T7xYYilheUXOHKMMyqVav+4A/+QK/XHzp06MCBAw8//LDb7U6lUlNTUxRFWa1WhmEymUw0GoVU43g8LoqiyWSanp5mGMbn89E0bbFYQMrEYrGRkRGv15ursQiCCIfDly9fDofD9fX16XQ6kUiIojg+Pl5dXV1eXs4wzPT0NKS1CIJgs9lgE+QcLQD3+FgsRhCE1Wq9a4vZ7fapqalEIpGrFSBm39fXd+LEiWefffbhhx+enp7+yU9+cuTIkaVLl/I8H4vFKIoaGxszZgEl4fP5MpmM2WzW6/VwkhRFRSIRyDYWBAHaiiTJYDDIMAzHcWC7bjKZDAZDMBikKApOIxqNQumouaUe6FeKokwm0xyG9PA4XOltX+PxeC5evJhIJHQ6HUmSiUSip6enrKwMWjKdTptMJvC/5zgOkssFQejp6Tl//vzOnTudTufDDz8MO1Znz398Pl86nQbpZrfbn3nmGZPJdOXKlQsXLixfvryuri4ejxuNRpgKTk1NcVnuqnEpiiouLv7BD35QXFwMiR8Q+Q4Gg8lkEuYbEFOHR0DDkSQZj8cVRREEAToLkvVlWZ6YmBAEwWKx6HQ6URSTySRBEOPj44Ysw8PDiqLYbDZFUSKRCMhBcMqH3SAURY2OjgaDwaamptwhyrJsf39/Op1esmQJ8QUCW5O//e1vb926dXh4+KWXXnrnnXeampqKi4ufeeYZlmUDgQCs2MDYiMfjk5OTHMfBpVEUJQjC0NCQNhUfHR09d+5cY2NjU1MTpGBJktTR0aHX6zdt2mQ0GnU6HUVRbrf7mWee4TgO0u1gPY1hGNDlIN8HBgZSqZTNZhNFsaur68KFC7t374YxMDw8LEkS9EJuHrwoiiMjI7IsWywWjuNgZk6S5OTkJE3TcM4cx8H3KJFI5P4oGY3GL7LlEQRBkE/Eoo64UyQhSkSfXyx3UQ4jlRGVD/szEzGJY0hBIiSZYCjqzEBmOCRRBFHvZfiMMh6RGErNsdHQEl10Op3RaFy3bp3JZJqcnGQYprW19e///u+ff/75oaEho9E4NTX10ksvCYKg0+laW1sPHDig1+t/85vfnD179ic/+ck//dM/Qd1HiqJOnTr1P/7H/3jjjTcEQdCi4DRNHz9+vLOz8/jx4++++25/f/++ffteeeWV//iP/5iYmNi3b186nT527NjJkydfeumlv/3bv+3o6JhP2BISeRmGgbDfHHJWkiRQ0rBnTjuyLMscx7W0tFRWVm7btk2W5YKCgieeeAKKko6MjPzmN785efLkX/7lX77zzjuQIJFMJl955ZW/+7u/+/DDD0HHQ0jy/Pnz77//vsVimZycfOGFF2Dz6L59+/r7+1Op1H/+53/+z//5Pw8dOqQoyrEsIF9Onjx59OhRbQJwp/NXFAVU712VLkmSFoslk8nAdtUZz0KaxOTkJKireDw+NjYG53/lypVDhw5BCPP999+/fPmywWCgaXp8fPzdd9+dmJj493//92g0+t57712+fHlGsBzmAC+//PJf//VfHzhwgKKoWCz22muvjY6Ovv3224ODg//5n//Z3t7++uuvj46O6vX6VCoF2S+QPzN3L8PxQeVDPBv6/cCBA3/1V3/11ltvwZUKgvD222//+Mc/fuONN1KplF6vv3LlytGjR1977bX/+T//54cffgjj0OfzvfDCC3/zN39z/vx5giASicTBgwc/+OCDH//4x/v27Zuenv6Xf/mXv/3bvx0YGJiamvrVr36VyWRYlvX7/S+++CJkKJEkeeTIkZdffjkUCoGuhWEAJ/D666/DXosvLOgO606wplFaWvrss8+Gw+H+/v5wOPzrX/9aFMUzZ84cOnTol7/85VtvvWU0Gs+dO/e3f/u3r7zySiQSgQD2wMDAP/7jP/7kJz9pa2ujafqVV14JhULPP//8jRs39Ho9eFa+8cYbPp/vn//5nwcGBmARCbLLYrEYwzCXLl2Cvjh69OjJkydh5WFoaOh//+///a//+q9+v9/n8x0+fHhycvJf/uVfIpFIIBD4P//n//z4xz8+f/68lt8iyzK869/+7d/+/u///vr165Cvdfjw4ZMnT/7jP/7jP/3TP8GvkyAIBoPhww8/hOUjg8Fw/vz5d999F+1HEQRBvsws6t9okiRERdXixVbaqifDSeX6uMCQ6o5V0At6hpiOS50+gSDJcgcjysp0QqYpcraaAL3LsqzT6YSF6fHx8X379pnN5mQy+fbbbycSCQi7QhprMBgcHh7mOO7q1avvvfeey+UaHh6+dOmSyWTq6ek5ePCg1+vt6+trb2/XIu4QzLNYLDabzeVyJRKJt99+e2RkpLS0NBgMdnV1gZrcv39/Op1mGObtt98OBAJ31e7gXQMq4a5JFxAmTKfTM/Q9wzAjIyMVFRV2ux2era2tpSgKYuEffPBBV1eX0+m8cOHC5OSkwWD44IMPOjo6XC7X4cOH+/r6QKLBosSNGzcIgvD5fFevXo1Go4qigBJ66623+vv7CwsLT5w4MTg4qChKe3s7BDJ7e3t5nr/rlcqyLAjCXQPz2pXSNA0qc4a8VhTF6/UODg7CaYN0tlqtiqIEAoHh4WFQUWNjY1NTUwzDgOGPw+GAXAij0djb2wuTNLDdhERzhmGOHDnS1dVVXFx8+vTpS5cuwbWn02mPx6NlsAwODg4NDZlMplAo1NPTM391C/HdgoICr9cLCS3nzp27ePFiaWnphQsXTpw4YTKZzmQpLS1taWk5fvy4Xq+fmpp67733IpEIx3HvvfeeIAiyLB86dGhyctLj8bzzzjt9fX0Mw1y+fPnSpUsej+fy5cu/+tWvIDXo1KlTYL45PT3NsuzY2Nj4+LhmqFJZWdnR0XH69Glt14der29raztz5kxxcfF9KW4KHp0URS1dutTpdE5PT2cymba2NlEUI5HI/v37I5FISUlJb2/v4cOHHQ5Hd3f30aNHYaXlzTffBNH89ttvT0xMeL1enU5XWFioXQhN05Dh5nK5YCkMEsza2toURRkfH3/nnXdsNlsoFHrrrbdgPpBMJq9cuWI0GoeGhj788EMYRQaDwev1six78OBBQRCKior27dsHow6ymOLx+JtvvplIJMxm8/79+ycmJnQ63bVr106ePGm32/v6+i5fvqzX62GWLghCV1cX5NB3dHTE4/G8KbKGIAiSlyxq4a7eqhUikJDtRsqip6K8MhaW9CwpZnOPlayyl2ViIKBG2d0mSpSIKK/MMoRUAX+9eDx+6dKlRCLh9XpbW1vD4fBzzz23e/fujo6O0dFRnU6n7cwDlzeQbhRFffOb31y9enVra6ter798+bIkSb/zO7/T3NwcDodzA9vNzc1lZWXNzc1btmwhCCIej69bt+7pp5+WJAlyGMBCbseOHV//+teHh4f7+vpy19BvCyQAQO7EXYU7zCJmlLmBq0gmk263G/wxBEGgaVqn00UiEbCprq6u/u53vwuBSUmSzp49u2XLlh/84Ac2m62lpQWULkmSRUVFkCQTiUR4ng+FQkKWgoKCcDi8c+fOP/mTP7FYLB0dHbW1tbEssOmzqqrqrj42ECnXJMvcV0pRFMuyt7WDlGW5qqqqv78fzrmnp6eqqspoNIL41poRotrQOC6Xa926dS6Xa8+ePZCvDAPAlsVutxsMhmQyefbs2VWrVn3nO9/xer0tLS1gBGkwGLZu3er1eh955JG6ujq32w1mIH6/X6/XFxYW3rUkltbLH3zwwcGDB995553u7u5MJnPx4sWysrLvf//71dXVYH1z+vTp0tLS7373uw0NDadPnwaDxXA4vGXLlueee256ejoUCgUCgdbW1k2bNn33u98VRfHatWssyyaTSZfL9b3vfc9kMnV0dDz11FOPPvpoW1ubxWKxWq1jY2M6nW54eLioqMhgMMB0a9u2bStWrDh8+DA8y7JsLBY7cOCAzWbbu3cv5AJ9weWBoOMymYwoioWFhcFgUHNjZFlWEISdO3du37797NmzOp3uRz/60ZYtW9ra2lKp1MjISF9f31NPPfXVr341HA4PDQ098sgjJpPpiSeeqKioyGQykDi0detWu93+1FNPFRYWwtACQ0YwGorH49/73vfWrl0bi8Xg6wwy+tlnn123bt3ly5fNZvP69eudTudXvvIVlmUvXrz4+OOP/+AHP3A6nZCNBtszhoeHOzs7H3nkkeeeey4YDMIm1EQiYTAY4Hemvb0dtjXDFzMej/M8n06nA4FAdXU1bk5FEAT5MrOohTuZNZZJZBQTR+oYMiMqwYRM5UgFkiTSIhFKqg+a9aSkELygbk79aHfqLZEXDodbW1tPnz59+PBhMC3p7u7euHHj8uXLN27cWFxcrIXEtHcBHMft2LGjtrZ27dq10WgURMC2bduqq6sffPDBysrKXO0I6bNms9nhcPA8X1tbu2vXLo/Ho5VlSaVSa7OsWrWqtrZ2aGjorgvfkAMzY5vgbYF4HqQGzRDuUMbIarWCVIX9taIoQtZsaWnp9u3bly5dWlFR4fP5gsEgz/Pbtm0rKipat24dKGAQc7AZIBwOx+Nxg8Hg9/sjkQhsw927d++DDz5YXFy8dOnSQCDgcrkgjzydTkej0ZKSktuK7BlALdi5X6NdlNYyM56SZbm6unpiYiKZTEqSNDQ0VF9fD5+eu7tX+xt62Wq16nQ6l8ulbS0VRRHmHpFIRBRFn88ny/Kjjz5aVla2d+9et9utuehAdSGHw2EymcrKyvx+fyqV8vl8sDV5PvMQSE/62c9+9g//8A//63/9rzNnzkQikXA4/Oijj5aXlz/55JNVVVV+vz8cDj/xxBMlJSWPPfZYKpWanp4mCKKqqmrDhg2rV68uLi72+/0jIyM2m23btm1LlizZtWvX2NhYKpWCfbT19fW1tbWNjY1r1qxpamoC1x2v1zs6OsowzPDwcHFxMZyqIAgcx331q18NBAJHjx6FRYnz589fv3798ccfLykpARNM4osFOh3GsNFohLxwGPbJZHL9+vVbt27V6XR9fX3r168vLy9fv349+BQNDQ3V1dVt3LixsbHxoYceomna4XDAdlXYhgHSH7adzNg4DiNhYGBg/fr1TU1N69evX7lyZSqVgsvftGnTihUrNm7cCCaVDoeDZdmCggJRFGFIuFyu73//+8XFxTBxZVl2cHCwsrJy06ZNTU1Na9eu7evrA9+YzZs3NzY2bty4MZFIwNcqk8kUFxfzPJ9IJEKhUCqVKikpwXA7giDIl5lFvTkVkBU12Z0kVREvyR9ZPQIKoT4ICfHgIDkDuCWPj4+/9NJL8DeEliORSG1tLWw5LSgomJ6ehkLrufdFiNEWFBQQBAH/DQQCiUSitLSUoii73Q7b+7TXa9WCaJoWRdHpdOa6QIACgGQMWEMPhUJ3VXWfHc2QDrbuwQlDSA/sKY1Go91uB1MRcIJPJpNnzpyxWCwffvghbI2Fk7darRzHBYPBeDy+bNmy6elpn88HgrWoqKijo+PixYs9PT2VlZU2m02n0/l8PovFQtM0hOrnI/U+Y2vAvKW0tLSzs3NsbMxms0Wj0e3bt09OTs5xZE0OwhlCZHRsbOyFF16AKkuPPvqo3W7nOM7j8UiStGTJkrKyMi2Urr1XUZSSkpKurq5gMDg9PQ1TRCjnNPc5w+ThwQcftNvtyWSysbExFouJouj1ejOZTGlpqd1uTyQScHxFUdxuN8uy4XCYoiiv18swjE6ng7wv2MsII7O4uBhCzhaLxW63g/MJ7B7mOM5kMgmCUFZWNjAwwPP89PT0tm3btFNKpVKrVq3atGnT0aNHt2zZ4vV6Dx48WFpaunv37tm5WF8wsDgD/jDaFM7tdoPXUDKZ7O3tPXDgwODgYEdHRyqVCoVC8L3LZDJbt24Fz034UmgXovV+7oMwp8pkMolEoqKiAnaOgi4HkyWYoMKaDBwTDmUymTiO++Uvf/n000+vXbsWknzgPAOBANj7MAwD3xqe5y0WC5ROczqdsizDNhVRFCELC7ZE63Q6qIt8H1seQRAEmZtFHXGHoLueIXlBESSFoQmLnpQ/Fk0nWIow69SiS+AkwzK50fbsEbI3S7vdvmXLlpqaGlmWly5dqt340+m0JEkmkwmis5qxo/Z22OAIWeYMw4B4MhgM8EbYwaa9GHzlpCyQjAGZJLlHg0AaJHNDIPyuGkjbHXjX5oJs3RkHBFFoMBhSqZS2yxBEBtgawvHhEUmS4Kx6e3tv3LgRCoW8Xi9oBYi4kyQ5NTUViUSampp4nh8bGysoKKAo6vjx46+//vqNGzemp6fBVN5ms01MTExNTYFmmk9KNFiM3/VlWrz8tjMBMOuw2+3Dw8M+n89sNoMYmvH2Gf+EvtNUEQybSCQSjUbD4TBshIX9talUSqfTVVZWaseE0DuUsIUsi0AgEIlESktL5385Op3u4YcffvLJJ59++unly5dDfhRYZFIUVV1dDVsjWJaFfoQOBS0O4V5QjTzP63Q6SZISiQREjiGgC9VktVOFkLAoihUVFYFAYGJiAuYA2uoQjMwnn3xSkqRDhw699957Q0NDTz31lMPhAFlJfOFotRFYlo3H4zabTesCGNWQESdJks/nu3HjRn9/P0TWwQhIEASe571er8fjgbkH7F7QjgCdNbswEwwPOA5sXodHwEGS53mY6WklGjKZDMMwO3fuzGQyL7/88osvvggLPuAnk0qlwDcJthdDv2iHgmk2nBUEGoqLiwOBABj+wBf2i295BEEQZJ4s6oi7ko2j2w1khFeSacWsIwtt9GBA0rNqajsId4YmSh20JBPBhMJkRbykJr9/dBDY4FVeXv6Hf/iH/f39f/EXfzE1NWW32+EODYIGbsaaapxdJVFzg4YdonAXn10vE0Kn8JQmJrSjaf+EpBeIQN81CA0HBLE1t8QHIaK9fsZTZrMZ9mJCeRcwRrRYLNPT01q8Gc6QJEmGYdasWUNRVG1tLRSrAlUE3uf9/f2iKJaXl4+NjQ0ODtbV1UUikcOHD1ssls2bN8fj8XQ6bTAYCgsLp6eno9EoaNz55HlDKHSedanATn72fAa6qbS0dHBwMBKJVFRUzN7XC10wu7QQbHKAMeN2u7/2ta/B39XV1eDfB60niiIYiWpnDlkQsKICO2ITiURZWdn8g9OQ/mEymWia1uv1WtUe2IQAm2W1dAtQ3lrhJOg++CBoE9jDALMRbaBqsWR4MTxbVFREUVRHRweYoGu6EMRxXV3dww8//O677zIMA5s3otHo/dofCd8XnU6XyWR8Ph9Esmf3oCRJNTU1TU1N0WhUkiRYfIDmYlk2Go3Cy+BbPCOp7LZrPvCtiUQiRqMxHo+Hw2GXy6V9o7XybblW95IkPfbYY16vd//+/e+8886aNWuWLVumTcZglgUv0zpI+xpqXQkenRUVFePj41ar1W63m0ymeDyOxjIIgiBfWhb1D7SiEDRFFtvoqZgUSqlbVOsLGFHKZrFnxbmsECYd1eBlJEUZDYscTbqMtCQpM268oFFCoZDT6fR6vW1tbRzHaTmy6XQa7sRQrRMcr+Px+Oz7N2SVGI1Gv99PEEQ6nQYX7dmfNUeZpFgsJkmSIAjhcBjCgXOHosHNA2YXc9+wwU8GYre5x4RT8ng8nZ2dcHUEQYAbt81my83VAWlos9nAN3Pjxo07duxYtmwZKAkQxEVFRd3d3Q6Ho6CgQJbl/v7+0tLSqakpRVG+/e1v79y5s7CwEIR+SUlJLBaDvaHzyQiCNQ2IIt/V8R2WMqBlZhwZ/M5ramoGBwdbWlrAPweegi6GuCZ4Wc5oJW3JAvq6MUtzc7Pb7TabzalUCnK7p6enOzo6tPPU3iuKot1udzgcsJe0pKRknglCM3ZWwBwJthPALAs2ksJHg1NkKpXKLRyrXTvsrwAL0WAwOIe9ptbdLpfr8uXLkPKUu+4ENQeeeOIJMCP66le/eldro88VmDPrdLrOzs5AIOD1emeMXqhgZTQaa2pqtmzZsnXr1s2bN1utVovFEg6HYTmlr69vYmICLuSu0Ws4JrhRDQ8PC4KQSqXALHKOdoDzTKfTy5cv/2//7b8tWbKkp6cHYgSQWA/bSMC9ymAw3GmHOnRQRUVFb2/v1NRUWVnZF2nBiSAIgnwKULgT5U5mOCjHeNnIkZurOD1L8hlFx5AMRcR4uamYqXGrcce+aZFlSK+VUvPgPy4RIcqVTCbNZnNdXV1LSwvDMOCyFw6Hh4eHe3t7tXTksbGxdDp95coVuJtqMTkIrbEs63a7z5w5IwhCS0vLyMiIVuoIhI5erx8fHwfbFi2dQNtaynHcpUuXxsfHfT5fW1tbUVHRXRsBtIggCODkPceUAFJ6NKGfK2jS6fTq1aunp6ePHj1K0/TY2Njhw4drampcLldulXs4Ycirbmtrg0pGhw8f1uSaLMuFhYWTk5MWi8XlcmUymbGxMdh4x/O8zWZLJBL9/f2QSlRaWjo+Pj4wMFBZWXnX5QIIXhqNRqhadbeBocpuaO3Z0x6YC5WVlaVSqbGxsZqaGm3brs1mGxwcDAQCUExX62IoS8nzPMzlINoNBaT0er3BYCBJ0uv1JpPJ8+fPgy8kuMrAezmOg0RqiJhWVFRcunTJarVCpae7drG2qpNMJuPxeCKRgDwQcISkKOrEiRNnz56FepynT5+mafrs2bOQAA1aULtwURSLi4vHxsZ6enrABgf2X2pBXBiW0NrahTscjlOnThUVFc1uz0wm4/F4nn322W9+85tQrut+ZbdDjlk8Hm9ra3v55ZeLiooqKipg0Uy7Lhj8BQUFV69ehRWDX//619FotKqq6vr167AM8sYbb/j9fpjc+v3+XCkMbQJ/wxdfC6g3Nja2tLQ8//zzv/zlL8fHx+EbAeNEa0zYnh4OhyORSCKR+Od//udoNFpTU5M7c5Nlubi4uLu7e3R0NBQKXbp0qaioCOyJtN8ZOBRckSiKZWVl09PTAwMD5eXlmOCOIAjyJWdRp8rIBKFjiKWFzKF2fiwsVbqYpmL2wSW6Yz1pf1xiabLGwzzaoLfoKV5QOiZFk46scjGZj29ghXxusGMjCKKxsfHIkSPd3d2rVq06derUL37xCwi3l5SUcBxXXFz85ptv9vb2jo+PQ/l3cBSBwFs0Gs1kMitXrrxw4cLPf/7zRCLB8/yMFPbS0tK33nrr1KlTkiTBojxksMTjcVAVqVRq37594XCYYZja2tq7eq1IkmQ2myVJisfjcxc8B1922Bg3I+IOyR4rVqw4ePAgyNZgMPjcc89xHJdOp2H7KVhVxmIxq9Xa0NDwxhtvjIyMnD59etmyZdB0cByXyxUOh00mE0TreZ6Hso42m+0///M/i4uLx8fHS0pKUqlUYWEhJNA7HI75JLgrimIymTKZDCSRz12tKRwOg9n57GdjsVgymfR6vbADoaCgIBAIgH8OzDFefPFFi8UCjpZQOhQcLSVJeuONN/7gD/4A4tmKouQmulit1uXLl7/33ns+n+/cuXNPPPGENiTADvzNN98sKCgoLCwEC7/i4mJi3kiSNDU19eabb0Jsu7i4+PHHH1++fPm5c+cURTl9+vS6desMBsOqVatOnz5NUdSVK1eam5thESCRSGj1oWKxWHFxcUlJycGDB1tbWycmJh599FEoXgvDGHavQpJGJBKBaVtBQUEoFCosLJzdnrBLdcuWLdo+h/uSpwEB7CNHjgwMDExOTvr9/q9//etgZAnVfGEHMKwLrVy58oUXXoCiSGNjY7Is19TUmEymX/3qVxzHTU1NQaJLYWHh66+/XlxcXFlZyfM8XF0kEgEhHo1GwRQfuripqamxsfH8+fOFhYUVFRXpdBrW5SD7Bb7sMJXief43v/nNY4891t/f/4tf/AIceJYsWQLGsul0urKy0uFwvPrqqzabLZVKgb0PGKfCbwWUR0gmkxDXh32r8Xi8qKjothXHEARBkC8P1GKPuJNkYyFDUcSZgUyMV+wG8tk1xo1VnNNIlzvor682rq/gCIXonBS7fFKNiy6yUqKk7lLNOYgaEIX4Jc/zVVVVxcXFfX19S5YseeCBB06ePNnZ2fn4449D7ZXt27f39fUdO3Zs9erVEC4FfzeIrkGMedWqVWvWrDl48GAmk1m7di3HcdpniaLY0NAA9W7A2SP3BODvVatW9fb2Xrhw4eGHHy4rK5tbuOeu/gcCgTlMV0CyBAIBs9l8W9WrKMrevXvNZvPbb799/fr1Xbt2NTY2gns0nBtBEGazGXa/7d27l2XZN954w263f+1rXwPNp23zraysLCwsBIeTpqYmaKXNmzdfvnz5xo0bzc3NcBDwwqupqZnPRkYth57juFAoNHdKAHjJu93u2wbywSHHYDDU1tYuX74cLLdhmlFQULB58+bTp0/39vZu3rwZIp0ul0uWZZfLtXTp0mvXrgUCAbvdrtfrtaRqLRr6xBNPkCT51ltvlZaW7tixA66RIAiTydTc3Hzjxo2pqSmSJD0ej8vlgnjwfOLTkINkMpmuXLlyKktraytBEA8++KDD4di3b5/Van3ooYfS6fTu3bvdbvebb75pNBofffRR2OIM0zlwIuc4zmKxPPbYY1NTU0eOHFm9enVTUxPkz8BChMlkgnkgmAjBIlJBQUFJSQkY5szuF2hwbVcGcT9QFMXlcvX29p44cSIcDu/Zs2f9+vWwWxf2q5jNZiiIm06nV65cuW7dOqiW9Y1vfMPhcNjt9scff7ylpeXMmTO7du2qqakRBGHDhg09PT1DQ0Pa9wXaBL5KYIukTTv1ev2zzz67c+fOr33ta01NTeCgDw0OqVlwGlartbGx8eLFiwzDfPWrX21tbd23b9+SJUtqa2tBuAuC4PV6H3/88Y6OjlOnTm3fvr22tlYQBHAUhfUTOAeTyQTFyGiarqioKCwsdDgcX4AJFYIgCPJZIOuf+gmRLzCUPJ00/a/db+ys6o/EYnT1/0UUf4cQpgny9gsLivoWIp5W/j9vR/umxf/zW/baAiaRUUJJOZ5Wt6I6TZSJIzma/IfjsZev8P/fPZbHGvWJzM0keC19BdIP3G433PMmJyeNRqPT6QyHwyMjIyzLlpeXQ8YLz/P9/f00TUMSgsfjgdA7GMlNT097PB6dTuf3+0dHR10ul8FgYBgGqnJqMWkoWGO1WuPxODiuQAqEy+X693//9/Ly8jVr1kxOTtbW1prN5vnkkLAsOzk52dPTs3Xr1jleryjK2bNnGxoaPB7P7KI/MAeYnJwcGRmxWCzl5eVWq1WW5WQyGYvFvF4vQRCQB+z1egVBGB8fDwaDLpertLQ0dxogSZLf74d8aPCWLigooGk6Go0ODQ1p0xW73e52u/+f/+f/qaqqeuaZZ+aTYgHZ+devX4fEntvWLYIODQQC7e3tW7Zsue0xwUDdbDaDv43H40mlUpFIBOZmoVBoeHgY8p7BgX5ycrKgoIDjOL/fHwgEKisro9EoOLvP8PokCGJkZCQcDns8nuLiYhgSTqdTr9eHw+GJiYmSkhK32z0+Pv4//sf/+PM//3NI95/7qrVFIXB/16ZqJSUlJElOTk5OTU253e6ioiKYO01MTExPTzscjuLiYihQAPMHiqKmpqZ0Oh3kuI+NjYFvqcPhyGQywWDQZrMZDIZAICDLckFBAc/zgUDA4XB4vd6TJ0++8sorf/EXfwES9p5Lw/b2dofDUV5ePnctKvj6tLW1lZeXFxQU5L4YJqUQXIfcHovFAn4skOwOTzmdTlhDCAaDY2NjLMtWVlaCayTP84ODg5BDBXtwU6kU1JxyOBygqrWj0TQN+WAwKrxeL2zIbmho0Ov1f/3Xf11VVfXcc88NDAxYLBaz2QzFyJxOJ7w+GAxWVlYqijI4OJhOp8vKyjRfI0jNgo+GEgo2m00QhEAgYLFYTCYT5Fx5PB5YPXM4HGaz+R/+4R8YhvnDP/zDcDiMBZgQBFnAKCLBuonxX0r9f2ezWI4NVP/Zka+6jQlRzp849aJOlSEJQpAIq57aXqc7P5h5oyX1R9vNdgNlM5AsRSrqs6pGP9Ofea8zXeOmV5exvPiRas/1gvR6vdpG0vr6+nQ6DZVEy8rKSJKMxWIQ+bZYLJs2bYLYOSRd1NfXJ5PJTCaj0+nq6+th3bykpKSmpgZs0cHWDRQG7JxbuXIlGD56vV7YigpW8TB/IEly7dq1wWAQckLmU4AJHE76+vpGR0erq6vhILmaBpJMurq6OI5zOp23lUfgiNLQ0FBTUwM+lXAcq9Wq6R4wGIlGozRNQ4aMlvCjwbJsfX19IpGA7GeO4yBJwOl0gsSXJEmW5Vgsdvjw4aGhIUjVmGePy7JcVFR08eJFmDPMSAyAS6Aoqru72+l0gg3i7Cutq6tLpVI8z0M5oVgsZjQaXS5XIpGQJKmoqKi8vBwaDXYOLF26FEzTy8rKampqotEoKDmtW7V2hlxnmqYh5M+y7JIlSyAJx+PxVFRUxOPxqamp/fv3w47PeTr3QUB32bJlkK4NEW4oyltXV1dfXw+5LiCp6+rqli1bJgiCZvROURRcGuwlSCaTOp2uubkZ5gPxeJxl2erq6lQqBQV9oE10Oh001I0bN957772KigqbzRaPx++kC2eY8Hwi4L3zGQZ3+hSSJCsrKw0GA3zjkskkJLfo9Xr4VkJiEgxpURSLiooqKyu1bBYIyW/YsAGShaBnbTbbli1bYrEYuFtCuj8cTZKk2tpa8EWtq6uTJCkYDB44cGDv3r1+v7+jo2Pnzp2KolRVVYHFpF6vr62tjcfjkiSVl5fX1tZGIhGGYTZs2AD7BLTN7vB1NplM69evVxQFtjvTNF1dXQ3lUY1Go9vtjsViMFWLRCItLS03btz4xje+MR/rWARBEOT+sqiFu8aGSm5lKft2G7+8hN1SxXEMqWMUWSH4jBJMKS9fTgbi8nfWm1xmSpBmVmgCd+Rc5+lAIAD6DwLhWkYEhOXAd0XbyRcIBCB3VhTFQCAAxnCxWAziYblmkVo6u9/vh0fgQ0E/8TwPi+CQZQv39fknHjAMU1JSMjQ05Ha7YQeh5sgOHxEOh0dHR6uqqjQT6BlAKBc8SUBCQYPA/AH2w8HcBnIqIDMHXpYrF6CCDOycgwaEbXyQbK25cKTT6RMnTrjdbsgYmc81gqaBEGNvby/EO3NNtRmGoWl6ZGQkEoksW7bsTjomGAyCQQ3k7oPOhtwG0KyajoR+h26FtGaI6Ecikdxu1dCaBZod/gmHhYULg8EwNjZ2+fLlPXv2gC/hPC9cFMXp6ekZuyQVRQkGg7m9oD0CpweSXdt6q502HC33PKFUE0VRWhfDeDaZTK2trSMjI9/+9rfvajZKfCrgc8GqfI6Iu3YVgiDc1mopEomEQqHcawcRD90Xi8W0LoNehgnn7K927iOQ7q99I7SjkSQZDAa14WE2m4uKiuLx+P79+2OxWEVFRVVVVToLvF0URRh12ihiGCb3xyR3OgSZ7qlUSjsZRVG0DhIEIRgMwhXB5tRz585xHHd/dwYjCIIg82SxC3eKJNKiUuGkH2/U908nfn4uORWVHqzXlzvotKi0jgv72/hLI8KacnXTqppb83ET95sH+bgC04wjZtuoz35Ee3Gu48Qcq9W5L8t9EEJ6zc3NkDIL9Vbm2Qgg7EpLSycmJtrb21etWqW5VmtlUNva2gwGQ3Fx8RxhuTudW26DaFHP2a+c8XpN+Grv1QpPgliEpKD5pAPlHlxRlKVLl547d25sbKy6ujp37y9MD9rb28vLy8EJ8bYH0U5vhqvPnfpudrfeqX9nN0tu02nLIA888MD27ds/kW3fXbvmTo/kDtfc653xMu2p2V2s0+meeOKJ1atXf05llSiKMhgMIKzvWkcskwV2V88YM7k2TRq5HiwzXjz7NO76ZZ/hKgN/wAbuioqKH/7wh1evXtXr9WvXroXiBnP/OMxRpWH2U7P7TvP/KSoq2rBhg91unzvRCEEQBPkysNiFOyDJxI46Xd+09NLl5L5WpX1CtBlJQSQmY9L1cdFrob67weg2k2q4/ct9X2toaIAaQ5/0BgwxvLq6utbW1vPnzy9ZsgRcU9LptM/n6+zslCSpubkZgn/39+4OQXe9Xr9jxw6oRvSJ3g47KZcuXdrb2xsOh2tqapxOJ2xUGB4ehlqY1dXVX0I3a8jLKi0t9Xq9Vqv1y+/cBxPCFStW6LJ8imE5/32lY2NjPp+vpKTkTh0HK2N9fX1WqxVqTn2pRCpFUfX19bBVHXYzf96fCPMcnU63adMmu93+JRzwCIIgyGxQuBN0NujuNJJPN+szonJxKHOki4+kFJYmi2xUUzG7Z5luTRknyqoLzZfpXn8bYEfdp7jrg8byeDyVlZWDWXw+H+SgQwp+XV2d0+n8nLTXJwWMdCoqKqD+/KeYpVRVVUWj0WAwCIfSLDUhhd1kMn05ffG0faLz2b3wZQCS/sFs8XM6YVmWrVar0+ns7Oycmpq60+DXMvIbGhq+bCIVKiGA2Su01WfJHfqk0/WSkpJ0On3fJ+QIgiDIfEDhria/0CSRzBDVLvoPt5neuEZdHRN8EVnHknUeeneDbkuVDpxkvvz3NUj8+HQ3YFAPtbW1Nputq6trdHSU53mDwVBQULB69Wqn0/ml0rLgV/PpLhYKT65YsWJ0dLS/vz8YDIqiaDaby8rKmpubDQYDmGcTXz5Afc7OzvrSAnHuz/WEtUK2ly5dunbt2hw57rCnFjb1ftlEKmSiQ2L6F3lu9+VDEQRBkE8NCvebkBQhKYRFRz7VbHikQS/ICkWSOpqw6NVSqblOMl9mPuPdF0LsNputqakJqsNQFMWyrMFggL+JfLlYyBcvLCyEZGK4dsjo+Cz2Jl8AX+Zzuy8nDCkfer1+1apVjY2Ncwh3iqLAuZz4UnK/enbBjSgEQZDFDAr3j1lDkgThNlE6G0lTamKMICupjJISFPrLJVk/R8BwGkrngCQSRVEQhPxbSZckieM4k8kE+z5lWYYr/ZILd2Q2oMWhCNTcL8OcEARBEGRBg8L9IyhSTZuJp5UofzNNVjWAI4nFo9q1rZ+weq5J2Fxb97wB8tohuQiuVON+nxryaUilUnNH07F/EQRBkIUOCvePQRKqTKdnOz4uJhaPuFk8V7oY+LKlciEIgiDIPQdvdQiCIAiCIAiyAEDhjiAIgiAIgiALABTuCIIgCIIgCLIAQOGOIAiCIAiCIAsAFO4IgiAIgiAIsgBA4Y4gCIIgCIIgC4C8toNUfdkVtZCS6s+OIAiCIAiC5C+KKvny2+c5PyPuar8phCKruh1BEARBEARZFCiq/FNFIJGf5Kdwz6IQJJMtqYQgCIIgCIIsBkiCpIn8JU+FuzrPogg5TSjS/T4VBEEQBEEQ5ItBJmRB/f88DbnnX447dJRCEIzCTxJSQlXwas4TgiAIgiAIksdQqvBLT2X1rSYI84o8E+5q96iJTbAplaQIRc6qdjL/eg5BEARBEAT5CJIihAiRGVdIVlGBR/NKAeaZcM+BZAhhmlAkVbYr4v0+GwRBEARBEOTzQ1EIliQYQs4QpGosmJfkk3DXJlbZWRalV2IdBD+m6KsUJY27VBEEQRAEQfIXJZsqwxOqqwypEGSOtQwkX+QDeSPccyZWCqkohCyT6pQrdJEoWaYQXN50GIIgCIIgCDIbkiSVwD6CH5MVVlEEQsnVfnmi3fNGuN+EJAiKJChSoSiCJiUifIwgkrg3FUEQBEEQJL8hSZIInyGkCMFQqhQk80Kq57dwV93bVdWuMAxJExki3UeMt97vc0IQBEEQBEE+f2gTQbGkQlKUQuYmy+QLeSXcyaypDPytGsuQpLpFlbbe7/NCEARBEARBPn9Iclb+NJFP5Idwz/ZJ1j5mlukPTdBsfmQ1IQsDtebXjLJfVLaKG/nZjil/fGxnJ6U4sJEFPbCR+4Zy61clFzq/603mNXK2Qz+6RygKKSm0vPi+niShMIRIfmxsZ5Xhzfz2fEhzzw/hPgcSIUSzNbQWfFchCwPaQFD6nB9QklAyaj0I1ZP00w5CWk9Qho8dUx3Y4c90TAS5BwM7rtbKQBYcJEnQ5uzkP6dD5QQhJ/Mvr2ARoBAUq3ZoDiRBWJm4jsospv4kSUIRFCYhGpW8vjPmj3Cf1Uu3hivnyf48IcgXgsQTqv0odevfsloPQuf9TKEs9ZiZnDGejRnoCnBgI18cUio7CHMHNk3oitThjSw4FJmQktmIu/arIhO0kWCdkGaALDBkUZ105eggklBCgi0jc3lWe+hukAwpGulU9u+PXXg+leHMpxs/5Mlo2TKkunLEOomy3ydMSzA2iXwhKMTU2+r/tJufIhH6MqL0+4ShilA+7crP9LvE1JvZ0GZWJCkSwbmJsh8Sxhoc2MgXgkz43iL8hz42sA2VRPkP1ciIukaPg3ChoKgzLiFEjPw7keggSPbWwxLh3EoUPpMNMeRDOsGiQVEjOLE2YvTfCTFGkLTqZE7KGYn95djXzgdXU+RiWRMj1dshs8TU//vlLzq5sCQzs5RhnozqfBHuOZldH3vU+xTh3E6wjqzoyZM+Q77ESGo6QWqIiF5R81sUWU1xKX6OsG/ODsJPp2+ykbCMnwgeVQ+uZNcAvV8lnNsIxoYDG/lCkAhSR/BDRPQ6QevUkUxnB7ZtnWrggINwIaGoiyRSiihOEAN/ryY7kTQhpdXwVtGzhKnhVv4MduhCIdtZnJfITBLjLxIEoxAESwqHp3ccmtrl4z15E2a+K2T2jjvBFxRw079b/lLOM7faIF/Gdb4I95lQ6sqRsYTw7FF/pPixnBVeBPn8kAhjLeF6kIi1ZnfDCOqN0LVb/UMdhJ/uN0MiDBWEezcRPp09pkgYygnPo+rfOLCRLwiJMNcTzl1ErF39lzqwVxKuXWq6hRDJk5vhYgu6O7cT/neJ8En1FkmSaiDA3ESkx9QtqsjCQk0usBPux4jp95TMNE1RUcFy0P9gSLCVGCZFZRHdIyhCiYumQ/6djxYcK9L58jXTPU+FO0kRcoqwrlK3a8gZgtLd7xNCFgkMIUYJSxPBuYhMQN0VbVulRgEUhaC4z3DMuKrddUVEapiQecK6hqCM6sFxYCNfEIwq0C3Nqj4Qo2pYxL4xu4JEfIaBjdxHFPXO6NhEhI6pP1C0Sf1VEaPZn5T81Dp5DaPeF1gHYWlSpg4ZWPZ6tH4kVWymE7zE5at4vRMclYmLpquR5dWFQ7KSn79OVD4nO3FFqr6BuwuCfBFkrTZ0xTf9N9Q84Go1i/QzOW+QhJwmdCUEk022UcTs8Q3o5oF80QNbX6IKO3UiKhH6cjVqi1WpFzCk2olqD2Y9SfSlH98Bjyy47G4LwXkVWWRIKSjYg4KdIcXFptoJgqBJOSkZJtJehsrby6fyfMcGutIiXzwkd+v+p6ipwPfAdkNRBZPm3UayOLCRLxwyG1y/NZjVTY15fPtYDJAf7UxV/9Z+tZCFiSp4buZQSAotKov3HiGpl8/k8WjOg19eVcpkeyjXUgbAkCRyX8gZePdqwedjxTWgGBMGO5Evlo8t8uBKZh6Q26F4u1zofHRTILNBeGLxolAzfEqy/9MssYgFTh4I9znI4xkXslAGHvklPiaCfCJwEOYZ2KFIfqIQ+Ux+C3cEQRAEQRAEyRNQuCMIgiAIgiDIAiBvhHt+L4wgCIIgCIIgi10o5qmPO4IgCLLQkGVZkj7a9kpRFE1/SnMMkiSV27lV3ulxeJAkMdX7XiJJkix/tO2VpmmK+jThQugXRVHu1H0IsnhA4Y4gCILcfxRFMZlMZrNZlmVFURiG4Xk+Eol8CjEty7Ioihx3m/IrmUyGoiiGYWboP5ZlJUlCUXgPIUnS4XDodDpJkkiSpGk6Go2mUqlP0aGCIIDuz2Qyt+1WBFk8oHBHEARB7j8URU1NTXV1dTEMQ5JkJpMxmUwej0eWZU3qQcz1TkcA2U1RVCqV6uvrW7FixezXDA0NWSyWkpKSTCZDZoE3plKp3HjwjA+a+3OR2yLLcn9/fzKZ5DhOluVMJuPxeGBipjX73Ksc0Ow0TY+NjfE8X1FRcePGjRUrVkA33amPcPEEyW9QuCMIgiD3GUVROI47e/bsr3/9a51OxzBMMBjcsmXLn/7pn6ZSKSoLROJJkoS/QXYrWSiKUhQFsjJYlo1EIidOnFi+fDlN0yDj4GUEQbS0tJSWllZVVfE8D0egaVoQhK6uruLiYo/HI4qiFncH8QefS1EUasF5As0lCMLLL7987tw5m80my3IwGPwv/+W/7Ny5M5lM0jSd23ckScqyrMlxaHmt2Wma7u3tnZ6eLioqOnbsWGNjI8Mw0E3wXq1ztTfC/A37C8lLULgjCIIg9xmSJCVJqqys/MY3vtHa2hqPx3ft2lVRUaHT6QwGA8Mw09PTVqvVbDbHslgslkwWhmEMBkM0GjUYDDabLR6Pp9NpWZbj8bh2cEVRaJp2uVyCICSTSYi1w9Hi8TjP83q9vre3t6SkxGAwRCIRh8PBcVwkEoFXOhwOvV4fDodB69/XdloYgJimKGrt2rXl5eUnT56sqKgoKSmprKzU6/UmkymTycTjcZfLxbJsKBQSRdFqtSYSCVmW9Xo9RVHxeNxut+v1+kgkoihKOp1OpVKKokC3KopizhKLxRKJhE6nY1nWYDAkk8lUKuX1egmCgMNifyH5Bwp3BEEQ5B5z29ySuRNORFFsaGh46KGHXn31VZ/P97u/+7vxeLynpycejyeTyXXr1nV0dAwMDFRVVVVXV3d0dNjtdofDEY/H+/r6amtrJycnT5w4UVRUVF9fT5Kk0WjUPpSmaZ7n3333XZ1OZzQamSwtLS1jY2OVlZUVFRXd3d1XrlwRRfHpp59mGOby5cuRSKShocFqtcqyfOHCBb/fv3z5cpfLtci1IMS2oQXu2g40Te/cudNqtYbD4XXr1u3cuXNkZKSzs9Pv9zscjpqampMnT8ZisRUrVhgMhra2ttLSUo7jxsbGRFGsqKhobW31+XzLli0rLCxkGEan00G3KorCsmxfX9/g4GBNTU1JSUkwGIxGoz6fr7i4uLCw8PDhw4qiNDc36/V6SK//opoHQb4I8sYOEkEQBPmycFvzkLkdRUiSTKfTwWAwHo8nEolwOBwIBN5///2XX375nXfeSaVSb7/99r/+67++8847giB8+OGH7e3tBoNhYGDg/ffflyTp9OnTP/vZzw4ePBiLxSiKmuFOc+PGjZ/97Gdvvvmm3++nKCoWi+3bt++nP/3pgQMHkslkZ2fnwMDAe++9FwgEgsHga6+99uKLL164cIFlWb/f//rrrz///POnT5/OPebiBPb1QubSfF6fSCRCoVA6nY7H45FIZGhoaP/+/S+88MK1a9d8Pt+LL774/PPPX7p0KZVKHTp0KBAIQLpUa2trKpXat2/fz3/+8/Pnz0PODCTASJJE03QikThy5MjPfvazDz74QJKkkZGRt95664UXXuju7h4eHn7hhRd+9rOfdXR0oGRH8hIU7giCIMi9RFEUvV4/w8mRJEm9Xj+3loKkc23PKE3TAwMDDMN8/etfv3DhwtTU1Pe+9z2fz9fe3l5YWDg0NMSy7MjIiNPpHBgYuHTp0tNPPx0Oh8+dO2cwGEDngTtNPB4/evTohg0bmpqarly5YjKZLl26FAqFvvOd7/T39w8MDKxcubKmpuaRRx4pKCg4evQox3GPPvro0aNHE4nE+fPnCwoKvv3tb1+5cmViYkKn0y1O5xmItXMcZzabTSbTbFue26J1JYh+SZI6Ojqampo2bdr01ltvVVRU7N279/Tp0+l0mmXZyclJiqLGx8eLioqOHj0qCMITTzxx9uzZsbExrdkhl+by5csjIyNf/epXu7q6Ojs7aZpub2/fuHFjY2Pju+++u3Pnzm3bth07diyTyXxqO1EE+dKCwl39Pco1mtUevE+ngyCfCRy6yH3/OaVp+ty5c8FgEHYKwg8sz/NnzpzJZDLzH6Wg+TZv3rxu3Tq32/3cc8/97u/+bkVFxeDg4JIlS4aGhjiO6+/vr6ys7OvrKyws/IM/+INNmzZ1d3dre1LVfFCGCYfD09PTjz322NatW41GoyiKXq/32Wef/d3f/d2CgoLR0dHy8vKioqLVq1ezLDs+Pv7YY48999xzTqdzenp6cHDQ4XB85zvfefjhhxezaqcoimXZGzduvPHGG0eOHBkYGPh0mthgMDz++OOlpaXLli377d/+7e985zvJZFKWZbfbPTo6ShCEz+eDPJmdO3f+6Ec/stvtIyMjLMtqR6AoqqOjY/ny5X/0R39UV1fX29vLMIzNZnviiSeKi4vb29ubm5t/+7d/e926dfh7iOQlKNzVXwH4Ucj9hoNHwX09LwT5NGCECbnvqRR6vf7ChQvRaJTjOEgoB5f0s2fPgusLw9x9exWIfrPZvHTp0lQq1djYWFhYeOLEiWg0qiiKx+OBXaqRSMRms4XDYVmWL168CAk26XRay+UgSTIUCjkcjrKyMpfL1dTUlEwmIWH9+PHjYpZMJqMoiiRJkNoRCoXOnz+vKMrAwEBFRUV/f//p06e3bNni9XphuyqxyAAnn4GBgTNnzly9evXixYsXLlwIhUKf9NdGluWioqLy8vJUKrVt27ZQKHThwgVRFBmGsdvtgUAgHA6LoqjT6WKxWCgUunr1aiqVmp6e1m7HFEXxPB+LxXiev3DhQiKRmJ6ezmQyMPUSBKGkpOTMmTMDAwMPPvjgPJcFkPvLovs6fWYW++bUGU5hOEFH8mn3GIJ8kWg/nrIsw1ZC7acV/qvX6+ERzdjxrgfkOE4URZZlBwcHn3/++b6+vlAotGzZMrPZ7HK52trazGYzbCE9fvx4S0tLMBjcsGHDjCo/8Xic4ziYPIBpydjY2D/90z+Njo7yPL9x48Zc5+/u7u6hoSGCIGKxWH19/datWz/88MMf//jH3/rWt3bt2rUIv1mQbhSLxY4ePUoQxBNPPBEIBDo6Oq5fv75jx45PejSO4zKZjE6nO3/+/M9//vNoNAp5Ml6vd3BwsKurq6ysDHYq/+xnP7NYLH6/f+3atbAnGMYMePu88cYbH3zwgd/v/9rXvgZVmaBI086dO3/6059euXLl93//95ctW4Y39HsCSRCfUzuSn+vR85RFLdwVRTEYDFNTUxMTE42NjbDlxWQycRwHdmOxWOzz+5nWLGw/xXs1n9rP4byQzxeFIGSFoMnP5eaaTqenp6dLSkpgFx1YI2uO15/oaHO//rOMXiRfAWu/yclJKJYZCoW6u7tBo9M0HQwG0+n04OAgrHDW1dXNp1Ip2ERyHHfp0iWCIH7/93//9OnTqVRKr9eXlJS0trZ6PB6r1UqS5M6dO1evXi0IwrJly3K9IAmCgBQX+DjQ7ufOneM47kc/+hFkQmuW8JIk1dTUPPDAAyzLOhyO0tLS8vLy3/u93ztx4sTJkyeXLl1aUVGRTqcXlXyHloEllL1791ZUVAhZOjs7161bZzAYPpFzi+azfvLkyRUrVixfvvyNN95IJpMFBQUMw3R3d1dWVtI0bTabv/Wtb1ksFpvNtnTp0jNnzmgzK5qmWZZ98sknKyoqGIZpbGzs7OyEHzpZlrds2aIoyocffvjuu+/W1tZC7afPuYXyGZZWb1iCROgY9Q/pnrYlSRBpURFlwsgtoi/UZ2fxCnewlOrv77927Zrf75+cnIQ0ytHR0cHBwenp6fr6+vLycvjNmvHeT6GEZn86VKD4FDYFEIUiSRICDMjCgiQII0tmPofa6iRJjo6Onjp1aseOHZWVlVDyXZZllmWhAvx8RqymyOce5J9l9C4q0bN4IEkyGo22traOjY0xDJNMJvv6+mCEwIhKpVLpdLqlpQV2iyqKAtr9tofKHSTgYdLT09Pc3Pzd7363p6dHkiSWZYuLi99+++1du3Y5HA6GYQoLC7/zne8MDg6Ojo7m7oJVFMVmswUCAaiN2t3dvWnTpg8//HDNmjXf/OY3W1tbIVWD53mKoiCQv2nTptWrV1++fJnjuCtXrixfvnzFihV//Md/7Pf7a2trF5ubO0VR6XR6fHx8xYoVy5Yt43neaDSuXr26s7NzZGSkoaHhrr8DWi0kTXnDFO4v//IvlyxZcvDgQch1IQji2rVr3/rWt0wmE0mS69ate+CBBy5fvgw3a63NTSYTTdNLliz55je/2d7eDpVZYYyJotjZ2fnUU0+Vlpb+zd/8TSaT0ev1KNw/NSRBBBMKyxBWHTWdkDlaVdjyvbtzSQpRbKONHDkalu7hYfOexR4wO3369ODgIMMwkLo3PT197ty5Y8eOtbS0HDlyJBqN3jbZnWXZzxhrBNHz6ZQ3RVGZTIbn+c9yAsj9giKJuFof5h4fliRJURS7urqGh4fPnz8PxSZFUezv74/FYpIkzXPEwpYP+O8cCayfZfQuKtGzSABp1d3dPTo6CuMHStyD5oZpHugt2C0aj8fPnz9/p6NJWbS/IbUG7MDPnj178eJFmqYZhnG73Z2dnSaTyWAwFBYWtrS0fPjhhy+//PLhw4cZhoFdsHAEh8NBUdTp06fb29uHhobgaIFA4NSpU+3t7dqYb29vhwT9ffv2nTlz5j/+4z+Gh4cvXrz4m9/8ZnR0tKCgQDOrWVSATSdN001NTZlMRpKkZDLp8XhKS0uHhoZy9wHfCVEUod1kWdZ61mq19vf3HzhwYHh4GOphkSTZ399fUFCg0+mcTufBgwfPnz///PPPd3V10TQtiiJBEDCoYLfDhQsXfvGLX5w7d45lWUEQ4Idl37597733XiQSKS4uxr1qnxFFIVwmqqGQ2VjF1Xhos44S7+nwVxRiQ6XuaysNOladD+CNYZ4s0og7zM7D4XAsFtu1a1d5eXlra+uVK1cg+rJ9+/aioqL9+/f39vZu3Lhx9tt1Op0gCJ96lxKEzEdGRlKpVE1NzSe6E0BGRFdXlyiKTU1Ni7wayMJCUQiKIjKi8mF/Zn0FZ9GRHy07kp/1N4uiqGQyCdYZ586dGxwcXLly5fXr1w8cOLB+/frKysqysrK7jlj4XhiNxmAwaLfbM5mMKIqzFT9FUT6fDzKAP+m34LZLWMhCB36X+vv7ly5dWltbS9P0r3/96xUrVpSXl4Peomk6FotNTk7u2LHDYrGMjY2dOHHiTuF2URRhWgglM0G4Nzc3/8u//EtLSwvEa0mStFgsHo/H4XCk0+nly5dfvnz5//6//2+TyfSjH/0Ifp+1ozkcjg0bNvzbv/2bx+OpqqqKxWLr16//q7/6q/b2dkEQIBWnqqrqF7/4xYYNG3bv3v2Tn/zk6NGjDQ0NNTU1wWDwpz/96f79+9etW1deXr7Ywu1aJDsYDOYuhpAkWVVVBZJ67m806H5Ip5FlGeraGgyGhoaGv/u7v1u6dClkvTMM43Q6PR6PxWJJp9MPPvjgT3/60z/7sz+rrq5esmTJ6dOnBUFQFAWCVlu2bLl+/fqf/dmfeTyeJ554Ynx8HLqb47iKioq/+7u/MxgMe/fuBQehRdVf9wqSULNiWJr4o+3GFcWcmt5JEa9d5V+9krToc+5cnwFFIRiKWFLAbKhif3kxGUnKNEtisvt8WIzCHRIZYY9LIBBwu9319fV9fX0TExNut3vz5s3Nzc0FBQWtra2jo6OQMJD7XoZhDh06VFpaWl9fr83ytciQVplC24AFj8AnwlOiKIKRcF9f33/9r/9VC0VoGQjwz9xcBe2YNE13dXW99NJLTU1Nzc3NWnIh/HrmfiKcEvxWwkfDbVL7COSLVu0kwVDkKy2pbr+4tVqXq4clmZCzwfjP9hEKz/MrV668du0aREA7OzsrKyv9fn8sFistLZ07UwXmk5OTky+88MLo6KjL5Xr88cerq6uTySQMHngvhCfPnTvX29v753/+58lkkqbp245eCHdpwx4eD4fDLMsajUYtpVjLhfhMF498CUilUjabzev1kiRZXFxcUVHhdruhi0FnNzU1eb1eo9EIw2P2EcAzpLGxsaqqCvT0Qw895HA4UqnU0qVLH3/8ccipcLlc0WjU4XD83u/9XmlpKXzuI488YjKZoHIqz/N79uyB0QiDcNOmTbFYzGw2V1VVuVwut9v95JNPMgxTUFBQWlqaTqfXrl0bi8U4jquurt67d+/Y2NjatWuNRmNjY+MTTzwxPT29ZcsWk8mU+5u/eIBsIkhn1x7hef6uy26Q0rljxw6v15tOp4uKih588EG4VT3wwAM8z5eXl+/cudPpdMbj8ebmZo/HA6sl1dXVe/bs6e7uXr16td1uh8xVjuMef/xxWZYLCgr27Nlz9erVJUuWlJSUUBS1Y8cO0O47duyABcZ169Ytwp66h8gEsbGKe6he77XQMV5xmSlRIs4OpCcikj6buETBr72igI4nCVXckx9/EFLkYQeqKKn3OFr93pMKoYgiQZKEniFMHMXRBEMTLE2KkoI5M3dlMQp3iqI4jqNp2mg01tfXd3d3B4PB1tbWmpqadevWrVq1Cn6P7HZ7b28vaN/ciAJN0ydOnNi4cePy5ctzw41Go5GmaQhSwssMBgNFURD7gTVWURShNAksyJrNZvgnzAcIgoBoBAT1wQMBtDjcLWRZdrlcV69ejUajlZWV8KHwWRAHgk/MZDKCIFAUZTAYQMBBBAvUEs/zi3C198sATRN90+L+6/zWak7Pqr9igKIQHKP+V5DUH7JPjbYuXFJSMjk5GQ6HE4nErl27hoeHr1+/nkql5t6nRVFUPB5/7733YN/e4OAgTdPf+ta3YOgaDAaGYTTjPL1eb7FYZFnWKpCDUTecgE6n00weYNjDR8CmwKKioubm5nA4zDAMDGD41uBddqHDsmwmk0mn07AeaDKZksmk9ixN0+vWrZMkic9y2+6G6GxdXR2sIHEct3XrVp7n0+m02Wz+7ne/C3swBEFIJBJms3n37t3JZBIG2IoVK9auXasoSjQatVgsO3bsgEx60I5er/eHP/whKE7YW/l7v/d7oPB4nk+lUmVlZX/8x38MdoTPPPMMSZKZTCYWi9lstu9973sQ600kEotzlMJ0nWEY7W7IMEwikZiPsb0oips2bcpk8Xq95eXliURCEISqqqo//dM/hTW9eDyeTCYrKyuXLFkCvaYoyp49e/bu3SsIQiwWgyHB8/yuXbvg7Q888MCuXbskSYpEIiUlJZWVlYlEgiCIioqKP/mTP5FlOZFILE7vznsCdOqueh1DkYdv8GNhqc7Lbqthm4rZoaBkYIlURhGyEpulCS5rtiATRDKtyPAgQ+gYNfslnFIYStXuskKYOTIjEem0QhAKSRB6hqQJIiOpq9CJjBJJKjwr6xiSoTDsfhcWo3BXFAW8e00m0549e1566aWTJ096vd7du3eXlZWBAXAqlQoEAnq9/rZvN5vNs3+w4Dci1xBNKzWSu5EU9Hc8Ht+2bZsWkIDouBZ3hx+7XMsF7ddHluXBwcHt27dv2rQJdlPBi+GVuZ8ItzdtKQAWnXM/AvkiIUk1rL6vNZUSlKWFTKdPyGTjDSSp6nWvhSq13wP/dRhOVVVVBw4cKC4uhptrQ0NDd3d3PB73eDx36n0It1+8ePHEiRPf+c53Vq5c2d3d/Ytf/KKxsXHnzp3xeFwQhNxhtmvXLi0bQRtU2nCdMXq1cxNF8dKlS0uXLl21ahVE3bQxiffXPEAzVVQUpaSkZMYAkCQp92fzToIPtLt2HFBjsCkoGo1q74U0ek2aEwSRTCZTqZS2wTrXWAa+F/B27XMjkYj2UwkRlmAwCI9EIhHtUyRJCofDi3ZfNdywjEajJEnDw8PLly8HqS1JEsMwDofjrl9ekiS1ToQ7L/wNAabcLoBHtHdBD8ILYEgQBJFIJOCReDyuJe3ATAz+mU6nc++DX0gj5SckQZQ56OmE/PPzyZbRzO6l+i3VNq+F1mfz0VmaZLK3LK2NSUIV69rfSjbQbmDV5+ErpxBqbgzF5rwmu85Mkqr0N3CkLufFyBwsLuEOgW2e56HuxoMPPtje3j48PFxdXf3AAw+UlJRATNFqtb7//vsjIyOPP/447ImZ8f3PNT3QfvSPHDly/fr1hx9+eOXKlQzDhEKh119/3efzbdu27ZFHHnnppZfKy8tXrlxJ0/Thw4e9Xi84Ua5Zs+b06dNGo/HChQsGg+GrX/2qy+UiSfLs2bMffPBBU1OT2+02GAxr166FiOnBgwc7OzuDwaDVal21atXp06cNBkN3d/c3v/lNiqJee+21UCi0e/fu1atX+/3+M2fOOJ3OkydPrlmzZt26dS+88IIois8++2xJSUlugRLkC4CmiERGOdWX4QXl308nCFL9Xbsp6CXCaqD+/BFLfQHDC9my3tmEwk/8ETQNN7+qqqq6urqenp4bN26A5wbc5woLC+8UgoJ759WrVxsaGrZu3cpx3Nq1a1tbW3t7ex944AGCII4dO3bu3LnVq1fv2rULhlwgEHjggQdee+212traY8eOGY3G3/qt33I4HIqiXLx48fDhw/BGh8OxZs0ayGF9//3329rahoaGjEbj9u3bfT7fa6+9JknSnj17GhsbE4kEjskFDUmSgUAAduDQND07hR1UIMuyo6OjoLRuK99zXdVz5VfutFNLysr9Kb7TG2cU68g1JcydbGgJPNoHaZ+S+8/FBgh3j8fT1tbW2NjIMAzHcT6fr729fe3atfOZdd+2X7Qe0Zp9Rg2K3GbXjqB93J26O7ejF2d/3SsUgnAZqfYJsXVM/ar2+MWLQwJLk3Q2Ef2RZfrNlRxBEB90p4/1qFYZepb67gZjuYMmSOJ4d/rt63yBmfp/7Ta3jos2A+m10H9xILq6lH1yhUHHEIm08vyZZDAhMzSREpRHG/VldlrPkD87m+iYEk3ZuQFyJxaXcIep+eXLl2/cuAEWVz6fb/ny5Zs2baqsrEylUrDOe+3atc7Ozvr6+urq6ttGKGcUbGJZ9uzZsx9++KEoiu+8847b7a6srDxw4MC1a9c4jjt06NCqVavGxsZisdjq1asJgjh79uzDDz88MTHR0dGxevXqc+fOQXh+eHi4pqZm7969nZ2dBw8eTCQSLS0tqVRq48aNmzZtgkXnVCqlKEokSzweP378uMFgsFgskiR98MEH169f1+l077zzTllZmSiKZ8+ehQIWH3zwwejo6PT09MjISHl5+W/91m/hL9oXDIQWGIqw6slVZaya1H5LuCuqrTsJoQolG7SgKXUhcv5dpIUJtTyrTZs2dXV1GY3G69evK4pit9tjsdjcHguKogwPDz/66KMWiyUQCDidzieeeGJkZESW5c7OzqNHj0qSdOLECbPZ/Oijj3Z1dfX19e3cufP8+fPd3d08z7e0tCxbtmzXrl09PT0HDhwIh8MtLS39/f179+7VBhusEYmimM5y6NChnp4enU534MCBoqIik8n0iQyhkS8hAwMD4+Pj2iaHGQIahh9FUdFodHYWokbuGLjT33d9du5/3vYF2iN3fe+iQpZljuOWLFly5MiRzs7OoqKiRCJx7NgxRVHKy8vn4wl7226a449P9K65H0c+NbCeYTdSlS6mzy+Oh6UXLyZ5QclISq2HfXatYW0ppxCEx0p1+ISRkPRQve6ZVYZim+ob5jZSV0eElKA8vFRf5hBr3LSskP94PP5Ek/5rKw0Gloym5KGQ9JurvCQTHEN+Zbmh3svIsjIVk4ZOJVC1z80iim/B/SOVSoHCaGxsvHHjRnFx8e7du0tKSuLxOFT7GxkZeffdd4uKimCPy12VBAiRU6dOlZSU/OhHPwqHw9evXxcEoaen54EHHvjBD34QjUavXbu2bNmy8fFxkiRjsZiWoQ5Zg9FoNJVKffOb31yyZMnVq1dZloXC3d///veXLFnS19cHHmow69i6dWtZWdnGjRsfeughSP6z2+3PPPNMOp0+fvz45s2bn3vuuZGREZgzxONxiqJ++7d/O5VKHTt27JlnnnnggQeuXr2aTCaxFvQXjCyri4YP1uttBuoHm01/+5Ttx1+x/c2Ttr/+iu3HT9r+6ivWShfNCwpNEcmMHE7JnzTiTpJkMpnUiiJ5vd4VK1Y89NBDbW1tnZ2d6XQaOn2OkDbMWu12O+xGDQaDTqdz3bp1UM2EZdkf/vCHDofjgw8+EAQh1xE1EAh885vfrKura21tZRjm0qVLoVDohz/8YXFx8ejoKGy0gNv/unXrSktL16xZs3PnzuHh4bNnz+7Zs+epp57q6Ohoa2uDzR6ftaGR+4qiKLoser2ey6L9wXEcPA61jWBXD7IgkCSpqqrKbrdfunTp6tWrFy9e7OvrW79+fXFxMU628xWSIEbCUnMJ+9QKNRzuMlEnetLnBzMUSexcwlU56SNd6Q+6003FzKZqjqXJx5frBFE52M6f6EmvLGWbS9mUqEzFZa+FmorJh27wTUXsQ0t0HZPCux38RFT67gajx0ymBcVlVP97vDvdNSU+vFTvNFIZSU2CR+4Ew3yKJfkvF9nFMvV+rzCUwtCw0fn2QIDH4/HAviWn01lTU2OxWCBpD+IKAwMDlZWV27dvZxjmrouAEG4fHx+Px+Nf//rX169ff+PGjZGREUEQnn766erqao/H09DQMDExsX79+v3790uS5PP5CIIoKiq6cuUKRO4VRdm4ceP69eunpqYOHz4ci8UGBwc3bty4cuXKkpKS06dPa7k6cPJGo7GgoMDr9U5MTDAM8/TTTy9ZsuTUqVNms/nhhx92OBzr1q3r6uqCMtE7d+5cv379sWPHioqKVq1aBcbeqVTKZDJ9Lr2B3AFI+PtKk/7ScOYX55P/10OWm2NXuZnSJ2Zj8HqabBsXevzS0816BcpBzwPIAC4oKDCbzfF43O12JxIJo9G4YsUKnueDwWBLS4vH44GteLcd1RRFRSIRkiTtdjtJklD/UlEUR5axsbFHHnlk+fLl8Xj8l7/8pc/ng6JOMCZ37NjR3Nw8PDx85syZZDLZ39+/devWVatWud3uc+fOgaM8vNLlcpnNZrfb7fV633///eLi4gcffJAgiHPnzvX09IDdxL1veuSLQlGUFStWgN1WbuwzN40BcrqCweB7772H+20WBPDzYjab16xZc+HChZMnT3Ict27dusbGRm3fOZKPdpDK+cH0yhJ2V51ubRnbNSX99Ex8LCIX2+hdS3RDQenv3o9yNPmPX7dvquSOd2c4hvywP/P/Ox6vcNK/+p7DqiNZUq0RLsjE374fuzwifGO1wWmk/v6DxPud/B88YP79zUaXiZIUdZfqS1dSx7v5P3jA9NQKw608p3uT7U6SBENTqtAlKVUq3vxRWtjzAmYioO4aWchk116z9wOWlqYSclq4vdqG9Diz2ezxeC5evLhz50673Q5J7WazWRCEVColCEIgEGhubna5XKBj7vLZWeE+OTk5MTHR39/P8/zExERnZydJkqtWrerp6Wlvb+/u7nY4HOXl5RAg9/l8TqfTZDJp+6tMJlNZWZnBYIDtXNEs27Zt4ziuoKCgoqJihqcNFDQBDz6LxQLv9fv9hYWFBQUFUFLu2LFjsizr9fqioiKLxWK1Wh0Oh8lkstvtOp0Of22/eEhSleaVTvqBGm4qJiezmTCKWkFaYbJb8mlSdXlnKCIlEO+0pZZ6mdVlbCI934QZRVGMRmN5efmRI0dWrly5fv36RCLBcRxI6omJicHBwYsXL5aWlrrd7ttmusOAhH0gvb29+/btkyRp5cqVO3fu5Hm+rq6OpunKykq9Xh8MBrVwKUVRNTU1Op2uvLz8/fffj0ajyWQSKo2XlpYWFxfnbhGB0QuB/6mpqZKSErfbnU6na2tre3t7wQoJt5QtaMxms9frBb8R2KAMP7DgOKTT6Xie1+v1i9NUceECzq0rVqzwer2dnZ02m23t2rUw2wermft9gsg9RlH3ZZEnejL1BelHlulMHOMySybO8g8n4rKsVLmYQ+18IkMQHNHrF8vsDEMR/3Qy7o/LUV4mSDojqUmhDK3uN73SnznVl8mIRKmDDiaVltHMcEh8t4MnCCXGKzRFpkXl+njm+rjYOy3SFGHi7tlwIkkiLcgTgYTE84KkZi7I+SHcH1pbRixgbilaRfVMpEkxnDa5rDpRutU7M16dvXOUlZW99dZbLpersbGRJEmO43p6eoxGo8vlgoQZj8eT62I2BxC8hMIiFy5csNlsAwMDUJz53LlzH374IeQHb9y40Wq12my2qampyclJr9cL4XztlGCzPCgb2CCv0+kSiQRI81zhDvdCrbIg3AhFUUwmk2azGaKbBoMB6ttBoah0Og2SCP64V02PfFLkrOHjQ/W6YFJ1yAL/LLOBSmU3pKprRgqRFokSu7psdPhGut7LfKIboiRJdXV1vb29Fy5cMBqN1dXVqVTKbDZXV1fr9fqzZ8+2tbUFAoHt27ffVrUbDAYYLeAwU1hYODQ0NDg4CMVuGIaJxWIwG9SC6LlZOjCTBLNIhmHA34Nl2duOXvggGLGCIJjNZsh6h6nsZ29q5H6RTqdjsdiVK1dsNltZWRnDMNeuXYNBCJsoBgYGYKs9rq4sFCA+Jcvy5OQkWBtzHNfV1eV0OgsKCjQTWCTPoEhVlP/majIlKC4TVV/A7F2u/7A/c3k4IymEx0L90QMmjiHdJqrITskK0TYubKnRfX2VocLJiNJNPxkdox4kIxLVbrrERo9GJEEmKhzMYFD8+TlJztZ4imcURSbsRpLPypObwl25F8EySXFZdbvXldl1CUnJzjDVuPvN54kFC/NXP9xALFhyvRdVpIxA2nX9+/m4eNuMGbCgqqmpaWpqOnbsmNfrdbvdkUjk4MGDDQ0NDz30kN/vZxgGTKnnAwgghmF0Ol1VVZXD4bDZbG63Ox6Pv/rqq2azee3atb29veCxUFpaOjg46Pf7i4qKcgWNVjIJdkdBAAM8jDOZTDweLygomPGJueXrtBrysixDRFNLCoJntRdgtfn7C0USGUkpsNBey80fJZIk4mmlbULQbnyyQhg5sr6AOdmb3lbHba7kkoIyz2w2RVGKior27t370ksvvfPOO3/6p38KlqAURVVXVwuC0N/f397eXldXV1ZWNiPkCdbsBEGEQiFIeHjwwQd/85vfXL9+HYLrJEnC6JotrLVRB4pfURRwQEqlUjPsumeMXigoptmVakYfyAJF22LR3t7ucDgqKysNBkNXV5csy/X19QRBDA8PX7t2rbm5GffYLES/oNOnTw8MDMBPSiaT2bp16/bt27Ef8xgTR96YEK+NxpYUMH+8zWTWk+sq2D6/mBaUWg9T68m+SFEN0yiK+O4G4+9uMsXTagUlUVaTQyHbU1bN2tVhYjdQUV4WJUWUCYYkkhk1gEUSajxLUtRtYLKi/nGvNApJknxaqi2x/fUDm1glTNFcbqW/Ba2FGNWYJz+EuySrzrIUQ1DZjPc7v4WiqNWrV3d1dV28eNFoNHZ1dYHUkCQpHo/D9qn5eNOCLFYUxWaz1dXVbd++3Wq1iqJoNBoHBgYkSfrGN75RWVkJwp1hmJKSktbWVo7jiouL5zg4RVEmk2lsbMzpdEIGTk1NzRw/jiB3rFbr+Pg4lK5MJBImkwm2tCJfuvVHteDczYx2E0f+64eJfa0pllZ/4yAVnqbU/JlAQr44lHmwThdPq7+J8zp4NtRttVoFQSgqKtKs06ACV3l5ucfjGclSV1eXTqdnjBCGYVwu18DAABS1MRgM8F+LxcKyLMwkwYbZYrHAVo1cYK6o1+sNBsP4+LjNZguFQhMTE2AYp71Mq+NrMpkSiQScA5S0hFWmBf17usiBIcdxXGVlJcz3RFEsKioC+3ZJkmpra6EAp2bCPRt4JUwR5yipe9vaq7kOJzC0oIaddnqzd8RqhV0h8DHHWc3/Zg9xJJiUftJLgOQibTKsnaRWpA/eCJNe4guB47hAIHD06FGr1bplyxaPx5NKpXp7e8+dO+f3+/fs2WM2m+cooKaVKp//Cc8w5bztU5+oR5BPiqKo/mbVbnosIk9F5f5p8eXLqQoXXabWG1F0DHm8h28dE80GMsbLkaT6+r3L9YpCnOzN+OPS9zbkbKLL6ndJVmJpxchRLE2ytGpNE4grbvPna9yuqPdT0qBjGPXryFB0vgj3cOxmXYM8iLgrciZDpM2SzGV9Rm8LlHIoLCxsbm4eHR0dHh52uVxQUhueisfjd/19gfITUJImmUxC6ovf71+5cuXx48djsZjJZMpkMkuXLmUYZmxsDArfVFRUHDhwYMmSJR6PB7bDwhjSAuHaT9vy5csPHTpUUlLS29sbCoVmnE9uWB3uNKIolpaWHjp0aGRkpKys7NKlS263e0asPfct96r9kU+144cQoepENr5eaKW3VHMMdUu4Z+0gQ0n5aBdv5NT1x/n/vFAUFQ6HL168WFxcvGXLFkEQDAZDOp0OBALFxcWpVMpisZSXl/t8PoiZzZ7QLl++/MiRI7t37/Z6vVeuXDl27BgUnCdJ8urVq8uWLbt+/XoymfR4PJ2dnTCQNK0DU1mO42pra0+ePFlUVDQ8PDw1NZUrlWB7RjgcJkmypKRk//79Pp+P47hr1641NDRAsg2OzwUNzN+WLVsGP86CIDQ2NkK+O2Qhms3mOfxkQI/CD7JOp0un03eqscpx3IwiX5BYCKNIlmVIdzRngfWcTCYTjUZz36IoitVqhd9zlmW1kkyzPw7G+XysDyH7EarGwuz3TsUTbnsJMH+GYlLawpTFYgEPTZgMGAwGlmVzK0x9fpAkGQ6HT548SVHUqlWrPB6Pw+FIp9MlJSVGo7GlpaW1tXXz5s13kkHwjXY4HIIgzDFbm/GJUFcLOm7GU7FYjCRJiEyB9f69u1bkI5Rs9dNvrDFcHBJ+fSmZzCiXRzKyrCafiLIafvLF5JcuJ2mabPAydgNl4MgKJ/Py5dRPjsWLrPQPtqi7+LSjUQTBS8RYWNpWq1MIYigora/kvrVGd7w3LSmfo7khqWbLyPFYmiMyJPWREFrwwp2FZNsFL9yz/5Mohbx7Nggo3aamJr1eD+WKOjo6enp6aJqOxWIQepx7+Q9cq8FV3WAwbNq0yeVy7d+/XxCEt956q6Sk5Omnn06n02+++abJZOrp6WlqapJlubi4OBaLiaLodDpB90OBt3Q6DQEJWZZ5nhcEYdOmTYcOHXrttdcymUxpaemMuiHwGu31ENYqLS3V6XQHDx6srq7u6en57ne/C27ZEOCED9Legoub9xE1y+7WH7ygfG2l/ptr1X30EHhQFIKhif84k+ydFrdUcylBoeb980LT9PXr13t6erZt21ZZWSlJUjKZ7Orq8vv9FEVZLKqPDcdxkUjktuExWZZXr169f//+V199dfPmzWfPno3FYsuXL9fr9dXV1efOnSsoKDhx4kRJSYndbud5HgZVKpWCeydIJVmW169ff+bMmVdffdVqtdrtdm0nNGgyr9fb0tJy/fr12tpaURT3798P8funn34aN2DkAeBa63Q64WcWjLDgNwoeARF/p19p0NAdHR2jo6MOh6OsrMxoNMJ7Z1Tb4Xk+N0AOedh+v39oaEgUxdraWjDO8vv93d3d8NNnMBjcbnfuR9M07fP5xsbG0ul0WVkZnHZuEqP2Yhic85lV0jTN83xfXx9sZyotLWVZNte0PreswexLEEXxxo0blizwzaIoyufzSZLkcrlg8TYcDoNz6+zz/DxKL126dAlq/JWXl0NNcZIkHQ7Hk08+SRAETOnhmz77NCA5Hso12O32GTp7dtQcdtH09/dnMpn169fnZvTBYk5vby+smcNOGyzZ9vkhKcTWap1dT50ZSAsi0VDIOI3UxaFMPC1PRKRVpVxjERtJKXsa9F4b/dLlpEIQ0wk1E6ahUN2rqoWiYJ05JSijIcljJhuL2VBCfqRB/992mNsmBVH6mBy559KEJEmWoRiFgnB7ngh3YvEBgROr1drc3CyKIuzJA3Xr9/urq6vNZjNUq7nT22VZPnv2bEtLSyaTcblcK1eufOKJJ55//v/P3n9HyXVdd/7oOTdWrs45oxsZIEIjJyIQIAIJggBJURJJST9JIwfJ2TPz7LferKflGf/h8RqPZ54tWcmiSYkkQIIEQAIEkYmcG6G7ETrnVF256qbz1r0buCp1AyAiwW7sj3pRhVu3bjzhe/bZZ++f/s//+T+zs7O/853v5Obmzpgx4+23366oqJgyZQokdna5XPn5+enp6T6fDyw3w1sxmFXMz8///ve/f/LkyQkTJkAawtulAARdbhhGenr66tWr33nnnT179syy6O/vH/6TIanpkMcLpWaiJciWCmtVHQI916ZtPht/doJjfK6QVK2oMnfRmEE+gWPHjlVXV48bN05RFJ7nz549e/ToUZfL1dzc/PLLL3u93r6+Pr/f73A4wHqXciVm+S8uLn7xxRd/+9vfHjt2TNf1DRs2lJaWKoqycuXKf/mXf/nnf/7nwsLCl156CWxdt9Q3yWSyrKzs9ddfP3r06KxZs44cOQJJl+zSPnny5K1bt+7atevb3/72M888895776mqunLlysmTJ4OOeSQPGvnSuWXxgI7zdnZr8AZpamr6P//n/3R3dzscjldffXXVqlUgmm33RVhnf+3atYqKCpfLZbdsHMd98skn27dvNwzjhRde2LBhg8Ph2Llz5/vvv+/3+6PR6FNPPfVHf/RHLpcLLkAQhGg0+sEHHxw6dEjTtHHjxn33u9/Nzc21zSKpy4Qg1Suk5LtD+wmj03Pnzv30pz8NhUI+n+973/tedXU1WNbt30IfVFdXV1pa6vP57O1w+3/3d3+3YcOGF198MRQKcRwny/LOnTtbWlr+y3/5L5DY++DBgzU1NX/4h38I1wk/B+zP9hN7kNbefiMTJ04sKiqCdeq2D5KiKDNnzrx69er169dnzZp1u6fR3d39j//4jxMmTPjBD34AqUXsb1MfiO1UI4ri1atXw+Hw/PnzYcF66pKY+vp6Sum8efMuXLiQlpaWn5+PdqhHAWf1TQ192vhc8W9W+jpDWlW2JAn0Wp/eFzWOtyhrJzr+0wJ3VDEWVkhn2/V40ggnjRVj5QI/NyFPsCIuQCE0J5Y5jigaawno0ST51mzX8ip5fK7QHtS7Q4blRXPjpMzydMfX+YU8icLdbuWdTqetZSE5iKZpfr//Di0dGI02bNgwb948aHccDofL5UpLS3v11Vebm5uLi4vLy8t5nn/uuecKCgoyMzNzc3M5jguHw6IovvHGG5AeMhaLVVdXT5gwQRCEF198EXLR5ebmvvrqq16vF7LTvf7662lpacePHy8sLLSb4Gg0umHDBphKLigo+NrXvgbzA5TS2bNn8zwfCoXASur1el999dWMjIxgMLh8+XKO4+AUmzZtgkyrKN+/CqiG2VoBBiMiR1oD+pQCYdUEmd5jee7q6orFYuPHjy8oKKirqzt06FB9fX1VVVVRUdHly5f37NkTDoc7OjrWrl17u7fPcdzixYtlWe7u7s7Ozp49ezbESy0sLPza177W2NhYXFxcWVmZSCRmzpw5duxYVVVfe+21vLy8ZDKZk5Pz7W9/WxTF69ev5+bmQundvXu32+22+2Ywhf7gBz8Aw+fChQuh0k2bNk0URZAFD+/RIo8BcBQ5f/682+0uLCyklLa0tCSTyTFjxvA8X1tb29nZuXLlyluKLY7jVFX97LPP/H7/ypUrm5ubd+7cOWbMmMrKSl3X09LSIGk0REA6cODAuHHjXC4XuFU4nc4LFy6cO3du/fr1iUTi+PHjs2fPnjBhQktLy9ixY6dOnRoKhUpLS+3WEi5gz549ly5dWrZsmcvlOnHixLvvvvuf/tN/AmUJ49uIhd/vb2lpCQQC8+fP7+jouMO9Q0K9zz77DEIgXLx48YMPPigrK8vIyOB53u/3a5oGGY79fv/+/fu//e1vu93uYDDIcZwoipcvX/7Nb37T398Pkt0+bCKROHHiRF1d3fjx4yEE2cDAgP20YVkLJKOFBGow1IEUJbfzNbqbVymKYn9/vyiKM2fOhAWpQ64qPz+/oqKioaGhurp6yFnAQN7S0vKrX/2qvb29uLh4iGXdzvkdDAZhKCVJUmZmpsvlsl2kvF6voiiqqgqCAJ70MI2ck5Nz+vTpqVOnTpo0qaenBwf8Dx1YM/rWqfj/d63v6bFyb1goThdOtihHG5MGI5/VJ5dVySsnyIpuLjM9eC3aETTOtaprJjmqcoWEyjwy9TvN153v57wy1QySJtJTrcrxJmX1JMf4XMMr0/97MNob0TPdXK6P4zmz+3NKNNfPiTxq9y/gCRXuYJkAHxWYkYxEImfOnAmFQuDAd4ff6ro+e/Zsh8MBSlrX9YGBAcMwlixZAu6Vg4ODqqpWVlaCoydYRMCEP2fOHE3TIPIj9GTRaHTOnDkQf8Pv9y9cuDCZTDY0NFy5cmXjxo01NTVXr1599tln7YQmyWRy7ty5iqLEYrH09PSioiLw2oQlg+vWrQNzVCgUcjqdCxcujEQi8Xh8ypQpjDHogebNmxeJRFC4f0UwPWFuvgeOmSI+389/vdpVlM5Hk2Yi1bsE5EhWVtbZs2d7enp6e3u7urrGjBmzcOHCjIyM9PT0U6dOdXd3g6xP7YCHGN3T0tI2btwYCoXcbnfCApYJzps3b+HChYZhhEIhMD2KoggJB6LRqKqqfr//6aefVhSlvr6+sbFx/fr1Z8+ebW5u3rhxoz0hruu6y+XasGEDeBtnZWVt2rQJhpSQrvXhPlvkywe8tJuamkRRLCws5Hm+s7MzFApVVlZCOt7a2trVq1ff0jUZ7A41NTXf+973Vq5cefXq1X/5l38ZHByUZbmrq+vkyZMcx1VVVXk8njNnzpw/f37//v3V1dWZmZnJZFKSpKampqysrNdff50x9sd//MfXr18fP348pfTll19+9tln+/v7QQJCaQRz+6FDhyZNmvTaa685nc709PS33367tbV17NixiUSipqamt7e3vLwcEgAfP348GAxOnjy5qKjoDr6UkNajubn5b/7mb6ZNm3by5Mk333wzGo3m5+e3t7d//vnnbre7qqrK6XSePHmypqZm9+7dS5cuzcjIUBRFluVTp07puj5z5swhYccyMjJgPm3ixIlgLfL5fLZ30JEjR3w+H6RTOHv2bG5urtfrpZTW1dW53W5YUnV/rb0gCHV1dXl5eYWFhWD8tr+CwY9hGOPHj9+5c+fAwMBwTxie5+vq6gYHB2fOnOl2u+1vYbzR1dV1+PBhWZbHjx8PMZEDgcDhw4eLi4sh+a6madeuXcvOzvb5fJFI5OrVq2PHjpUkiVJaW1t7+vTpYDCYkZFRWlqKaQEeBRxHDjcovz0dK8ngPRJ3tlU9cD3ZOqjLPK3v0v7jZHxygZnXqLlfP9KgxFW2tSbBCFV107Ke7eEud2o6I1vOJep7NMlckEp7wsaW8/GYykSeJDT2yeWEZrBzbWpMZdEkc4i0ZUD/4FwiEGNWahPktjyhwj01Jh20ttFoFJwK8vLy7twKUEpDoVAwGLS3QHM2ODgI4sk2jYNAT90HfgUHh7VTlFLI9ASuDtBLZWdnv/322+FwGBa2lpWV2S0v5LywXSNgnZ/tWgqx/GA2E4YQcGRYxgQ/gdNhM/cVhFrxIquyeUbMacq7V+2giXNzc8eMGXP8+PHTp08XFhYuXrx40qRJsDauvLzc5/MlEomioiJVVW+3oguMauDDahczu5Ta56KUxi1g4Rps0TRtYGAAUn299957g4ODbW1t+fn5BQUFtvM6XGdfXx8US7Cr2VFNH85DRB4roOfANQWkp8fjga90XS8uLo7FYrezGkAjBqbinp4ej8fz9a9/XZbleDx+9OjRDz74gOf5TZs2zZs37+DBg7FY7OOPP/b7/fn5+ZChIisra/HixeFwGHJLRyIR0JqKonR0dEBYpFTTeE9PTzweh1FEIBBYunTpgQMHrly5MmnSpPr6+i1btly5cmX+/Pnf/OY3r127VltbaxjGhx9++Ad/8AepfvBD4DgukUhAgOCenp6CgoJXX33V7/dHIpE9e/bs3r0b5mZnzZr16aefJpPJjz76qLCw8Omnn4aKIIrid77znX379g0ZWkPtbmpq6ujoqKqq0nUdeoREIrFv375PP/00Pz9/48aN1dXVW7duXbJkyfz58zVN27p165w5c6AC3keDD+YteCCCIAy33IMhKScnBwzzsHYr1S0Kguq8/vrrbW1tjY2N9lfww88++2z//v2yLH/rW9+aMWOGoiiHDh3asmXLtGnTBEEAW/u2bdtWr14NOSXee++9v/zLv4Thyueff97d3T0wMOD3+3/wgx8Mj5GFPCDgmM4M9r/2RYrT+fJM/lybFlWYZAVAU3T25smYz0GdIukKGbJA3aKZNvVcmyryJBAzrJ9TniN/+UFQ4KhXNrMs+Rz0WKNyvCmZ6+U7grpgqfl3z8YNxkSO+h30jGmST0o8taM1ILfkSe8soavIy8srKCiYPn36qlWroP7fzQpXG3vjEPHxhQElb7lR07SxY8d+85vfTEtLmzlz5je/+U3w4xweD/uWB0RFPtKhVrzI+whmyxibN2/eiy++uGDBghUrVpSVldkB9RhjaWlpubm5Xzhms+OcDt/zC0sgz/MwvfPyyy+npaVVV1e/+uqrw0PFpWYhGF6JkJELuGwlk8lJkybNnDkT0giUl5dPmjQJrLO5ubmzZ88eHu4wdSkkpfTo0aOg+MHbsKur6/333582bVpFRcXOnTtjsdiUKVM8Hs+sWbMgNS+cdMKECZMnTwZPknA4nJWVpaqqy+VqaGj4p3/6p127dsHCD1tzBwIBn8+XnZ0N3pKwljoQCKiq+sknn0QikRUrVhw/fvzYsWNlZWUlJSV5eXmzZ8+2sw3APCdgj4R1XQeZfurUKUmSILO13++vr6/ftWvX4sWLvV7vp59+qqrq9OnTXS7X3LlzYQYM6s6yZcsqKiqGrwFIJpNTp04VBOHixYvQQ4F7Z11d3b59+xYuXOhwOD766KNEIuFyuZqamsBjB2IK39/kKrzKRCIxMDBwu5/bkYgLCgrsbA+pO+i6Pn36dFjllep5L8vy5cuX9+3bt2DBgszMzO3bt+u63tra+vHHH8+ePdvj8cDUBFimICaPqqq9vb3QD2qaNmHChKysrAkTJkyZMuV2QXuQB8ewFHxXyDjbpoaT5qoPe8mpwVgobvSaeVTNiWJIIhhKGIGYoRum27oZyd2KomaFdL/xM8NKMtgVMrSbPqKGwW74uFMrjjv6uN8FT67FPdUEmJ6ePmXKlIyMDDAU3c2vbrcx1agwfM9b/nOIpoGgZk8//XRJSYnX6wUT6e0OcjfHvxvJhXx10HSz5br7YDI24Dg7ZcqUSCTi8/mSyST4n0C3Bx8gFMMXavfhK/BuWVaHbwHh8vTTT5eXl0PptaPKDPnh8M/IiAai+MOaRYixCAGsQItDDCJBEPx+v67riURieEur67rb7Z4zZ87u3buDweDEiRNnzZqVmZnZ2dk5c+bMl19+OZlM/vjHPx4YGJg+ffrOnTvBnAzCHQq/pmmiKF64cGFgYKC8vBymjxobG30+34EDB7xe74oVK+zT9fb2+nw+yB5ACIFIA/F4vKenp6Gh4dlnn12yZElPT09TU9OKFSvGjBkTCATmzZtnq2rQ5fA5Go3CCg1FUXJzcydNmrR58+a2traJEydWV1eDpX/RokXf+MY3Ll++/LOf/SwYDM6aNevDDz+cP38+tPBgny4oKDAMY3iDr6oqBKg5evTohg0bQAQzxi5cuJCTk7Nx48YLFy689dZbHR0dY8eOPX/+vCiKPT09lFKogPddyzRNy8nJAV/52x0EAuO0t7dXVFQMLxJZWVm3s9YvWLDga1/72tWrV3/6059Go9GrV686HI5NmzYNDAwcOnQImqDUqDv27J+maZMmTcrJyZk4ceLUqVOH+PAgDxevg+o6iatmZkAQ4uAB75GoKdnNgAo31LZDMF8PYzc6L8OS6X4ntbS7HeyYOKnp8u4VqG4pfqdkvmDzCIxIPHGKnJm8CcX7HXnShTvAcVxBQYGu60NCbTwWoPWnlE6cOBF6OGyVnsx4kff+QzPhLky4Q8hkuzCD0f3uk7bcd0/PcVwsFhMEwS69aFB/QjAMIy8v7+rVq7FYDEZrdpwT+zPY3SFiOoQBGBJVnVK6dOnSa9euHT169MKFC8lkcvny5dnZ2d/4xjfsiOaRSKSoqAhyeEmSZK//AW8TSZIOHTqUbxEKhRKJRGZm5rp16z766KNDhw7Nnz8fRhegtmFJqD1YdTqdiUSis7PT4XDMnz8/IyPjhRdeaGpqIoQ4HA5RFD0ej+3uGA6HGxoabB90r9drhyt49tlnOzs79+7de+HCBULI7Nmzx4wZU1FRoSiK1+uVZTkSiZSWlnIc5/F47GXZEL9cluXbrT9ZtGjRJ5980tjYCH7eyWSys7NzwYIFBQUFoiju3r27paVlzJgxu3fv1jSts7MzLS3N6/Xed5RVmMdwOp0Q9+YO710Uxe7ubjtdd+q3sVjM4XAMD2BVVVU1ZswYWHUK99LR0TFjxowxY8bk5uZOnz4dOr4hoZDtcgKvw2FhB7xHHgWabvZHEv+72C83tt9U8NrNV6RboR9Tt5jRF35/9gjUvLnPzaOlHtb81jwK8gWgcL8BhOt67KodgGYIbFSo2pG7B0qLnXk+lS+tb4NTY+l9ogA7aHl5+dGjR+vq6u68RkjX9YyMjGXLlg0R7rZp+Uc/+tG5c+d27NixefPm8vLyyZMn19XVnTlzJhAIQDQViNVop8+0fw5LVM+dO/fGG284HI7BwcGpU6fOmjVr3LhxHMf99Kc/DQQCJSUlMK4AZwzw4gDFCSmTIpEIiMJIJFJQUJCbm2uf0Q49KQhCS0vLv/3bv8GNv/LKK5DyDFTp2LFj/+Iv/uLkyZM7dux45513QIxeuHDh0qVL3d3d8XjcPtSQW7jdbBho6Kqqqry8vMOHD6enp0MVU1XV5/PF43HIRzswMACJivv7+7u6uiCQy33H/4WTwiKW25lA4farqqog0vwtDzLcgxTGSJct6urqWlpaYBxVWloKjj23HCoMGePZ3MetIfcEJBi53VdfuOVufoXcEyjcb3Dn6LyPBdtS9bgvBEHuDbtDxdL7hABqLCsra+3atXc28cKeLperpKRkiOqCdYculwsM3pmZmf/3//7fpqamgoKCn//855IkQQpqe/9U1QuHFQTh448/zs7OnjFjRiwW83g8a9eudTqdhmGUlZVB6qKysjL4SVpamq7rEEMMfhsMBouLiyHJEYwiwMpuO7Xb2hTiopSUlNgePnaUSVmWHQ6HJElLly71+Xy/+MUvuru7E4nEL37xi9zcXDtcjJ227O6lpyAI8+fPP3HixIwZM+wEsaIowiAZPng8nvT09I6Oju7u7kmTJt13BQRF7vP5Fi5cCA/wdg6iMNMCIWXu5nSg2i9duvTrX/8aXPDBTQjCR0LhgURUdgNyu6eEwh15MkHhfoOvoML4Cl4SgtwNWHSfQMAOPWvWrCEeDrcThdFodHj0wIGBgbq6usrKSqfTuXjx4j179oRCofr6+s7Ozm984xtFRUV1dXV2aiRRFFPTarpcruvXr9fU1Lz22mterxf8zvv6+vLy8mCVtizLqWdMT0+HUJVZWVmQjrqzs3PSpElOpxOu3+FwJBKJ/v7+vLw8uDtYggmny8nJeeGFF2xXGTgyz/Pt7e2xWKy8vNzv9z/zzDO7du0KBoNNTU3xePzpp5/meR4cbOyMS3dZWcD+PW3atMOHD584cSI7Oxt+qOu60+mEBMaiRXZ29uXLl5PJZF5eHnkAYECSmZkZi8Xu8EJhmSzkMbybw8Lw7OzZs8lkcsGCBYSQzs5OmO5WVVWWZQjTbI8Khjz51OPccokzgox6sNAjCIIgDwHGWCAQ6O/vH7gj/f39ds6d1N/yPN/X1/fuu+9GIhEI0QgG7I6OjokTJ27cuLGkpASs2rAaNTVjFxhf9+7dm5ubO3PmzFAoBHkG3n777Y6ODsgZnEwmwRMdVCksRT1//jxIw8uXL/f390Ny60Qi0dPTI0nStWvXLl++zHEcz/OJRMIWlLDottSirKwMDgsS9vr161u3bgUnnMHBQY7jBEHo7OycP3/+c889l5OTY0+lDrmFL8QwjMzMzLFjx0JIe0mSPB5PS0sLx3GDFunp6YIg5OXlnT59GsIK38E3/QsBpybIb/WFFwZW/y/E9jXq7u6urq5es2ZNaWkppRRWLbe1tWmaFg6H29raBEGA+MV9fX0cx/X29g6/vGQyiRZ35AkEhTuCIAjycODumuFhRhhjmZmZzc3Nhw8fppRev369vr4+JydHluXe3t5gMHj06FEIlATpeK9duwZKGrwsGhsba2pqZs6cGQgEurq6BgcHfT5fKBQ6deoUpfT48ePJZDItLQ0CpGialpmZOXv27O3btzc0NAwODm7fvj0tLa20tDQjIyOZTELGpY8++qilpcXhcPj9/o6Ojt7e3iHrLIevvc7KyqqpqTl79izP8xcuXOjo6MjJyREEAS7p8OHD8EOe58EjH24hVYAONyTbQV1FUayurpZlmVIqy3JBQcHx48c7OzsvXLjQ09NTWFgIydEaGhokSfL5fA+eaO8uf37n3WDkY79lEOVtbW3hcPjUqVO9vb1Op7O0tPT8+fPXr1+/cuXK2bNnXS6XIAiiKF66dGlgYODYsWOSJMGYDWJ6wqAFygPKd+SJAl1lEARBkMePpmnp6enz5s376KOPamtrOzs7s7Kyxo0b19fXt3nz5r/9278FZ+tEIuF0OgsKCt55552srKxZs2ZBxusTJ06Apfnw4cPJZHLx4sUbNmyYM2fOrl27Wltb6+vrn376aZ/PB8IdtP7SpUvr6+v/9V//1eVytbe3b9iwwe12OxyOWbNm7d+///z5852dncuWLYPUUR0dHW+++eb3v/99EI4Qx92+eFDwiqKUlpZOmjTpzTffPHz4cENDw/jx44uLi8ePH/+zn/3sb//2bw3DAMd6QRAqKir+4z/+o6CgYM6cOeFw2Ja2dko++8iRSARSMiWTycrKyqqqqs7OTkLIjBkzTp069Q//8A/hcHjq1KmFhYXxeDwvLy8Wi7ndbpfLdU8W/UcEpCOEm7KXID/11FP//u///t/+23+z7fqTJk3y+Xz/+I//mJOT4/F4+vv7JUmaOnXq5s2bI5EITClA/m/IPzVu3Lhf/epXubm5r7/+ejAY/IoElkCQLwG0uCMIgiCPH7Cnrlmzpqio6Pr164SQdevWZWdnFxUVzZ07t7e3t7y8fNGiRRAJft68eenp6ZCXwPZxr66uZowpiqJpGhibFy1aVFZWVldXV1paumLFCljTacvHioqKZ599VtO0/v7+OXPmzJ8/X9d1nueXLl1aVlbW09OzaNGi6dOnx2KxwsLC6upqcCVPzY8xxOiuaZrb7X7uuee8Xu/Vq1c9Hs+6detcLtf48eMnT57c3d09ZcqUuXPnOp1OuIWMjAywGdsPwTCMioqK4uJiO92pYRjFxcWlpaWQ6UmW5eXLl0OepoqKimXLloVCoYyMjFWrVjkcDlVV3W738uXLx44d+xXx/9Z1vaioyE4sBU5HT1l0dXWNGzdu1apVsGbg2WefVRTF7XZv2LAhNzeXMTZ79uxx48b19PRUV1dPmTKF4zh4FPF4fPLkyVVVVZFI5CtymwjypUHr6+vJiMWeIIP19YauqDTN0fT/EiPHmJ4gZX9JCl4jah+hOLGAfGkYhHOTC2+QRCvRo2TCP5G0+UQLE/oAvQvTiJhJan9EgieIkSAVf0PyXiJqPxZs5EuEEc5Bal4jyU6ix8jE/0v81USLPFDBvg2qqvb09KSlpbndbtiiaVoymXQ4HHYWHjB42z4YqTFG4L929l9FUXp7e7OzsyFk+3DC4XAymczKykrdqOt6PB73eDz2Fk3TwFnlC68fMp319fVlZWXBUle4DEVRnE6nLfQhsyz4jaT+fHhEpiFb4E7tX8ViMUmSUpdvwujijrZ2RjgnidaTi/8P4R1E8JOpbz+6MH23jDGlaRo84dR7iUaj9r3ALSQSCU3TIH247RUDh4IZj+HrVp9EmEakbNLy/9Obf5Lulj7qWvb/rv/LbKlfY0/cwxGo3qekv1b0/l9X/mtfTGL+uYmy/y6yQY6XUoOTPvaZqAfhiXupCIIgyFcWjuPS0tJcLhfEBARnD4/HA4Z2sJSrqgqJSyEaDKxVhSCMdthyRVEgiY/f73e73ZC/c7jPtyzL4IHD87wdYZ3neZfLBdHE4/E4dPNer9fOcXYHwIcbUjJBiEa4QsgmC4MNCJwiiqLP50skEpBxzz6Cw+FgjKV6uYBTO6QzgwW7cLXwFQxvQODCTzwej6qqQw77uIALtq8fNsLzhCcMSXZ1XYd7ASsc3BHHcRC0HnaLxWKyLBNCkskkz/NQJDABE/KkgcIdQRAE+aqg6zq4LEMmVDCoR6NRO1A6z/MQUSQej8Nn+Coej0PCYNvizvO8nQ87FovBzkNOB0IcvN5hB/C6DoVC9kpKEI7hcDg1G/HtAON6IpEAbQ1GPl3Xw+GwPVcAJ1IUBW5hiMU9Foul+rgTQkCj207wqf+0YzWm3l0oFBqe+ehxAZJ9SH5D+3naAYXgvuDeYR/79dm7wegL9odycjdvBEFGGaNNuFPrD0EQBBmJQHDAITpvuDgbLkxvKVXto93OocI+cupv4VfDj3OXt2AHgbF/csuf305bD7/ZIVvu/GS+gt4jt3svQzYOv5fhu6W6OnzVbhP5qsFGqSb8SozIEQRBEMTm4To/PBZXCvTfQBDkUYDCHUEQBEEQBEFGACjcEQRBEARBEGQEMKpcxMypSUoxhRqCIAiCIMgTDrspDckoYvRY3FMcCm3pPqpeFTIieWh+rtyw8ozFG/nywdYVQb6apAT+N/+e6BrKrP/SlCZrNK05GT3C/SaMUPnGSmKWJEx53NeDPGkwYsR/125oYcLUBz4mJXrYKsxWwTaS1jFxbgn5MmFEj5v5xW4UwoSZ8wUZqTDCdPMl3qLVQkYmRpIYZh/BCBWp5uAU+oS+UCZxqswpN/JzmoJwtD2Hke0qY4fs/d0GwoiQRghPOJHEm8yizImEmdkcEOTRwwjvJtGrRI+Yo2IqmLkJM5YRyluK536PKbhJvIUoVg5gs2A3mg00FmzkSy7YkctmzlTKmeU5dpWkz7PSpo62TvHJgJoNSOyq9QY5oidIrJH4Z1oN1+gxTD4xMMLJZqLuRCvlRdXgc+XeDDEQ0d0SVZ4007tqiDKnlDnbVEMwWyohzRrA/N5DGOnW95Et3IcpeEqYbkh5jArmawqdJ0oPkfMsW8LIfk/IyIDpRHSQ4GmiDBBeJkQkobNm8aMCsXIB3u8xJRK9QpJdhBPMJih0hqj9RMrCgo18SZiFUCbBU0QNmQWbE8jgUZL/ivUVjh5HIpw5axc4YiobypnjseAxkjaPGJplZUBGFMwggss07kQuUl5O6NwYV3Olu/HY4EyXGNfZ6HOsuC2UMMWQch29T/kvx3WZ43lVyjObL6ujHOl6fbQJd3tlKjVU3VFpuQDxRO0jXe+Rou8SR6H95hDkEcIMEjxB+nffcG2nAom3moUw72WrEGr3UwgZI+EzpHc7IZpVYXmi9JKud7FgI18eTCeDx8jAHpjUJFQ0DbRd75OCrxHBb2l3LIQjBWYqdS1MuraQaJ35Ks0XypPAIeKrJhmLzVZrmIUS+QrDTMGTaCHd7xEtSKlsEOLgky/mfdKWKLgaKX9y3iQlTGd8oaPr5fxtWeKAanCUcrqjkjKVcGZGZDJaGD3C3cI0HehyiSHmcskmcyqwfw8RM4mz3BI9o+e1IV9d+vaQeAOh0g01w1TSs92cx5SL7r8QDhwi4Qu/OyahpO8zImYQRykWbORLgZG+3STebBZCYhfsjwjvMsshwdHjCIKZg38tSLq3mj7uVDRfKBVIopN0vWO6ytxwf8IXOlJglk/mFTJw0FJ0BkeoYoiz0s6/VLD93OAkjj4pc2LUtI3x5a7WZVmfG4SnRDHEQiaX8KOugaL19fVkJAM+7szCMNF1gxO635L637X6GGa+SpzMRb40TDctfqjjL1NNw/n9H5O/aQZ7eMdEkMdesJHHBjX9ncyp6dQwQbrpKoOMRMyVJ2Jq9TTlPNV4Oto06xfBDMZpTACvGSXzZS33GzxncBzPcZbV3bK7j3Tr+6iyuFsvw3wfmn+JGNxH9X5CJCu2zJNWdpHHh1kIuVsEcHgQdwLzmEPkETMPiAUb+dKAVYy/h1UC0U9mhHrLMN4MQHKLJgUZmbMo5rj6dzWREsZTQ6D6E7U4lVolWCc8MxQm5Gj+JbB5pCv10SbcYVmq/V9L4+i6XKykr5F7/52yKON9tzAUIcgjwtQxQ2Z4KBGcD3ZQY9isESWCAwUT8rgLtutxXQ7yoJgK5/e7RSoR/glayDi6sMZdv2dxJ3FDNtgoSz30xVBmCCxEKK+krzbkYt70JuVTDe2jQMSPeOE+BGuFqhlkWPUv5+O1fOwCZ8QxmjuCIAiCIE8Iv5v5fdKMllQyeI/umqL6l1NqgCYcZYwe4Z5qdDeXqAruRM7/IwW2SeHDVOtPsU2OuneIIAiCIAjyhMLsD0zwq94FSvpzRHBz5rJUbtQY2kezcDdfD6McRww5X0lbo7mmMzPJ343d2BM3/EQQBEEQBBmdUNsgSwnlHIaUT+R8jmqW8/QoWZA6OoW7DcdxBiGcYRCW0OUi1VHJCGcGn7EUOwp3BEEQBEGQUSXcKaxCNTiW4FmCowLlTMioQxhFaVN/N6Iyt1BKOYEzktT0cTfXVME+N11lUL4jCIIgCIKMXKj13xQFSM28S5QTbhjbb3Jj71Fhdx8Nwv2W3jKm3d0weJ43dEoozwhLjXyFdncEQRAEQZCRC01dtUhv/JMzgyOZInBU+smMNuH++0tUb4R153hri/XtTaM7LlBFEARBEAQZDdAUm7qtAEelah/lwh2M7qlvzjBuxCEefS8SQRAEQRDkyYHdtMaCL3uq/EPhPmLc3IeGl0l5kfarRRAEQRAEQUY09Ped1+3/2mIvVbWPGgU/SoT7LZeoMsY4zoonc/Ofj/UCEQRBEARBkIcMHbYCdYi5fdSo9lEl3O9sgB/yXhEEQRAEQZDRBB2NJvbRLNyH6HX4kOoqgyAIgiAIgoxW6DDX9lEmAkeVcL+ldrc93R/3pSEIgiAIgiCPBHorgT7KVPsoFO5DtHvqxsd0OQiCIAiCIMiXDR2N2g+jrCAIgiAIgiDICGAUWtzRPQZBEARBEOSJhY5GW/toFu7DXxuKeARBEARBkNEKHb1iPRV0lUEQBEEQBEGQEcBotrg/geMwBEEQBEEQZLSCFncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBGAQEY11OJxXwWCfNVhFvf9c6xoCPKFYC1DkK9+RfvqM5qFO6VUtXjcF4IgX2k4jhNFkef5+2jsKKWMsWQyqev6o7k6BBkl8DwvSRJUmXv9LaVU13VVVQ3DeDRXhyCjBNFiFGv30SzcNU1TFEVV1VH8/hDkweE4zjAMWZY57p595wzDUFVVURRN0x7N1SHIKEEQzA5XFMX7MJzrup5MJlG4I8idgYExpZTneTJKGZ3CHYwT0WiU53mPx4PTiwhyBwzDiMfjhmF4PJ57GuVSSpPJZCKRcDgcTqcTKxqC3A7GmKZp8XicMeZwOO61okENdblc9zG6RpAnB8ZYIpGIRqMej+f+ppG/+oxO4U4ISSQSoihKkiQIAuoJBLkDhmE4nU5bgt9lS0cp1TRNVVWHwyFJEsdxWNEQ5HYwxkBzq6oqWNx9RUskEoQQp9MpCAIKdwS5AzAwVhQlkUi43W4yGhmdwl1VVV3XYbxlWDzuK0KQry6UUkmSCCHxeBx8cO/yh4qi8DzvcrkMw2CMYUVDkNtBKeU4zuVyRSIRRVHAbeZuMAxDURSn0ylJkmEYuJgEQe4ApVQURY7jIpEIDJLJqGMU3hLoCXDYBSWBhkAEuTOGYQiCwPN8Mpl0Op1faAsEbzRd191uN6h2rGgIcmdgcOtwOKLRqK7rdzOPD+Z2nucFQcDuDEHuBsMwOI6TZfmeRsgjCG60No6je00xgjwiu/vdrzFVVZXjuNHqRIggjwLGGM/zHMfdfbgzTdPuaR4MQRDGmCiKtlFplDHahDsYAjmLx30tCDLyJAXUoLvZGYz0X8qlIcioAszndyMpdF2H+BijUn8gyKODs4AaREYXo1DdapqGzRyC3B8g3L+wpYMMF1jREOResSvOXTqkjT7ZgSBfWkXTRmOc4lEo3MHijo0dgtwrUHHuUrgbhoHCHUHuT0/cjcXdrow4gYwg9wq1Ks6oXMzNjcrY+9jMIch951S/Gz0B+gOHxwhyH9i17G5GyFArv6xLQ5DRA8dxo7KfQoGLIMjvGH1tHIKMaLBKIgiSCgp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwRBEARBEAQZAaBwRxAEQRAEQZARAAp3BEEQBEEQBBkBoHBHEARBEARBkBEACncEQRAEQRAEGQGgcEcQBEEQBEGQEQAKdwS5NwzDYIw97qtAnmgYY4ZhPJbzfvknRZCvJg9SHQyLOx98+A6Pq+IjXymEx30ByMNpOCilj/QU93f8B/nto+ChXI8sy7quY+v5hMAsoMw8lpJ8y0LLW6iqejc7P5SSD8+B49DWg4zsHu1hYRiGfZH3Wr8YY5IkEUI0Tbvdb1PruP1YBEHgOG54xUeeKFC4j2zsfvTRWcJ4noc++z5+y3EcpfS+f/6VuhebZDKJ8uXJwS7Dj8vefMtCaxiGpmnDyyFsGX6dcBcPMtr8qtVlZFTyJfRoDwtBEOxm4V57FkopiG9K6e3qZmodt48PQh87oCccfP0PB2b9fZlAPRdF0eFw8Dz/iPw3OI4TLB7k518R2wmlVBTF+7gX3QLMroZhnD17tr+//76fCTKCoJTKsux0OjmLL5zdfhQXIAgCz/P2Fui2BwYGzpw5M7zKixbDa5xdi++vlWCMCYLgdDp1Xf+KVGdklAFdmCiKsixDXbtzWdV13TZXf/lQSt1uN8dxUB+HVNI7A7d55cqVq1ev8jzPcZwoiqlaHI4ZCAROnz5tGIa9gyRJbW1tNTU1MGaAjumR3SLy1QXFx/3D2A2xTn9fvltz6r/b+GhOzRwORywWa2hoiMVimZmZJSUlUI0fYrfK83xXV9euXbsqKysXL16cTCbvaSrQ4XAcPXq0rq5u/vz5VVVViqI8xi6f47hoNPr222/n5+cvXrwYDBh3+Vu/308pDYfDkiRdvnz5vffeW758+apVqx7xJSOPGUqpoiiXLl0KBoNVVVWU0pycHFEUY7HYl2Dxgsn01tbWgwcP5ufnL1u2DGoQbN+3b9/FixezsrJSaxbP8x9++KGiKE8//XRGRoamadRC1/VPP/20v79/1apVaWlp99rZg85oaWk5duxYOBxesmTJmDFjVFVFBY88LAzDcDgcmqZduXIlEonk5eUVFBSoqprqjpIKY8zn8/E8H41Gv2TxCvb1WCz22WefNTQ0TJ48uaqq6tNPPx0zZsyiRYvuppfkeT4YDO7duzcWi40bN+6cxcqVK4uKiuBeGGOyLB84cODMmTM5OTkul2vPnj3FxcXLli07cOBAS0tLSUlJdna20+mEjunLunXkqwJa3O8fjiMCT0Te/C/82Z+5R9yjcRwXj8dPnDjx0Ucfvfvuuzt37qyvr4dOGna45bQdbEzdbs/02RvtfaB56u7ufvPNN48ePSoIAlidb3k9w49sGIYsy2fOnPmP//iPpqamIXMCw8845FC32373FzBkI6U0kUi89dZbe/futRvHL/wV/LO5ubmxsTGZTIqi2NfXd/To0cbGxuEXfMun+tWf8EXuYGPu7e3dvn375s2bd+3atXfv3hMnTgwMDIiieMtXfMvKNeSYd1NWUy+gq6vrnXfeOXjwoCAIUINARl++fPn06dN9fX32HDpY6bZv375169ZQKAS2QDigpmmfffbZe++9Fw6HwVZ3u6bgdk2HruvHjx//xS9+8cknn3R3d9vV+XaNzC03Yl1AbocoisFg8MiRIx9//PGWLVt279599epV8CG5ZRHiOK6tre3q1avxeHzIoe7QqQ3Z7Q7t9h1+aBiGIAgNDQ1vvvnmW2+9VVdX19PT89Zbbx09elSSpDt0XvbPKaXxePzSpUsnT57kOO7s2bO//OUvOzo6YJ7BHirX1dWdOHFicHCwu7v77bffPnz4MM/zly5dOn36dCQSYYw1WtzujA/8TpCvLmhxv0+grmg60QyiGcxglsWLMkGgImc2NjdM74/i1FatPnfu3K9//etkMgnKsr29/Uc/+lF6erqmafZuqUteUiXskC3Dj287s/I87/V6HQ7HHfrd4Ue2t8uy7PV6ba1w9zd4u+13MGbc8tvUjZRSr9frcrnu8leghDRNe/vtt1VVfe211zIyMnJzc4uLi/Pz83metwcA9vGHt/tolRyhGIYhimJnZ2d9fb2u63v27AEr+4sWtr35Dq/4DtVtyK/srnd4DeJ53uPxOJ3O1FpmGMbYsWMbGxvz8vJS6ztjzOVygdfskIO7XC6PxwNq/g7XcMvtgiAEg8FLly7JsjxjxoycnByY2bOryZAlel/Y8iBIKtDSHj169Oc//7nL5VJVtaGhoamp6Yc//KHf708t4VCEDMNwOp0fffRRQ0PDd7/73bKyMphcGlICU0vd8FJ9h3Z7yLXdctnoxYsXQ6HQlClTJk2aZBiGz+eDXnL42eHIqQfRNC0tLS0vL8/tdjudTlEUYfbAHifALNnYsWMvX76cl5fX29vr8/nAZ6+goCAQCGRnZ0cikTfffJNS+sMf/nC4lw7WuNENCvd7xmCEUvMvGGPX+7S2IOuNaEmVUUrcMpfj5SsyuJI0wSVzmiXnH3rd4TgumUyeOXOmubl55syZZWVlx48fv3DhwtWrV+fOnQumbrfbTSmNxWKJRALG8bARfgvjdYfD4XQ6Y7GYJEk8z4fDYcMw3G43TFlGIhHwrgMndYfDIUmSpmnRaPT3nobVhoJciMfj0Wg0VTTYP/d4PA6HI5lMxmIxQRDcbrdhGHAot9sNM4+wEMfr9YJbC1xVNBrVNA3kiyiKcIQhWgF+JYqiqqowcwrNpdvtlmUZNsJPYEm+3RzDoCKRSMRiMVuCeDweWZbtJ+D1etvb22OxGMxLFhUV/d3f/V1mZibMP8iybN97IpEghDgsIpGIw+GQZTkej8PBH3IhQB490H3CTMuYMWPq6+sDgcCRI0dmz56dk5MDk/WCIKiqGg6HOY5zu92MsUgkAj7lbrcbyp5dAaG6wboUqIagwiVJcrlcUDeHlBa7BskWuq6Hw+F4PL5u3bo5c+YUFhaqqsrzvNvthpLM87zty04p9fl8oij29/dD4U8t5Km1SRRFt9sdi8V4nne5XIqiwF0AgiCIotjT01NWVvbGG2/k5OQoiuJwOFwuF9wvyCa4EWh54hZw47CR53m4ZdQTyPDRaW9v7549e/r6+iZMmJCXl3f+/Pna2tqzZ88uW7YMho52CY/FYoQQn8/X09Nz7do1URRdLlcwGISyLcuyw+GAXs/lcsUsfD6fJEnwGcqk04IxBu02x3Gp1VMUxcHBQfBihx4EekzbmiOKYjQaNQzj29/+9vz58w8fPgx++bbPD1RnaPxdLpfT6YQ6xfO8z+eDCvLd737Xniize0m3251IJKD6PPvss0899VRxcXFXVxeszlIU5dVXX43FYmlpadFotKWlBR6FYRg8z1NK4aoEQfD7/YqiDJ+OQEYHKNzvDUaIwFNFNa716Rc7tSu9WmdQD8R1RTUFulOiGW6uLF0Yn6NPLhAL/TyhltB/qNfAcVw4HL5w4UJJScm6desqKiocDseOHTuuXLkyZ84ch8PR399//vx5XdcLCwtzc3NVVXU6nT09PadPn1YUJTMzs6KiQhCEzs7O9vb20tLSQCAAznaiKNbW1vb29rpcrtLS0uzsbMMwdF0XBKGjo+P8+fM5OTnl5eWpdjtZltvb21tbW3Vdz8vLKy8vT/Vlt+0Hly5damlpKS4uLi0tjUQily9fliSpoqKCUlpXVxeNRktLS30+XyKROHnypKqq5eXlAwMDsVisoqLC5XIlEomzZ89GIpGsrKzi4mKwdkMzCgGzTp48GQqFfD4f7A9jgNra2oGBAZ/PV1JSAkMFe36f5/l4PH7q1KlYLJabm1tUVASjFMMwLl682N/f73a7y8vLfT7f+fPnY7GYYRjnzp2bPn06zN6qqqrruiRJfX19LS0thmEUFBTk5uYSQlpbWzs7O8eOHXvt2rWenp4iC5y4HImAYhAEIT8/f9OmTdeuXfv4449bWloaGxsrKiq6urouXboUjUZ9Pt/YsWNh7pvn+aqqKo7jBgcHz5496/f7wRwoSVKHRVlZWSgU6ujoyM7OHjNmjK7rsiwPDAzU1NQoipKdnQ2LVVKvAXrl7u7umpqa9PT0sWPHQscvimI8Hvd6vYlE4sqVK9FodNKkSRzHwc9hsujUqVOKohQXF4OrG3Tq8Xj83Llz4XA4MzOzuLgYZMrp06dLSkpUVW1qakpLS6usrAR/GDjX2bNno9FodnZ2OBxOS0tzuVwdHR3t7e2CIJSXl3u9XlVV4UbOnz+vaVphYWFeXp6qqg6HY2Bg4OzZs/F4PCsrq7KyEu4ItftjwVyWZU0O3+vvrMb2Lnak7D6Wd/E8X1tbW19fP2nSpLVr1xYVFfn9/k8++WTXrl0LFy6UZTkcDtfV1cVisaysrNLSUlVVL1++HAqFJEmqqamRZTkjIwPKdldXV2dnJ5S95ubmEouampq+vr5iC1VVJUlqt+A4zu4iu7q6WltbS0pKIpHI4ODg1KlTDcOoq6vr7e31+/3QY9qdzsWLF3t6epxOZyKRALc0sOPA+pNAIFBTU6Oqal5eXllZWUtLS3t7e3p6+pgxY+LxOMzglZWV2f2ILd8vXrzY29tbWFhYUFBgGAbU8UQiARYECCmjaZogCIODg1evXoVu7vjx43l5eYFAgFJaXl4uSVIoFDp37lx6enphYSFWtFEJCvd7g6MklmT13ereq8lz7XpcI8zshBi1vNpjihFNsvYgqe1ReiP6wjGO4nSepw8z4Iztv9Hd3V1WVjZhwoTS0lJN0/r7+8EJJJlMfv755zt37kwmk08//fT69eu9Xm80Gt23b9/OnTtDodC0adO+8Y1vTJw4sba29p133lm9evX58+dDodDf/u3fdnZ2vvfee2fPns3NzV2/fj2svwTLAbgeTp48+Y033oCmE1zqQ6HQrl27PvvsM0VR5s2b941vfCMzM9OOvGE7yh8+fLimpubpp5/+zne+E4/H33777czMzB/96Ec8z/j8p7IAAQAASURBVO/bt6++vv573/teRkZGTU3Nli1bBgYGnnvuucbGxt7e3h/96Ec+n+/SpUvvv/9+c3Pz1KlTN23aVFFRYYsbSumFCxfeeeedxsbG0tLSl156ac6cORzHNTU1vfvuu5cuXSovL3/xxRdnzZqV+hgNwzh//vwHH3zQ0dExa9asF198EeT19evXt2zZcv78+cLCwo0bN86bN2/Lli29vb1Op/M3v/mNx+If/uEfnn322Y0bN0Yikf3793/22WfJZHLRokXPPfdcXl7euXPntm7d+uqrrx44cODSpUtLliz5zne+I8syaveRCIRuyMvLmzZtWnV1dX19/eHDhwOBAGPs5MmTH374YXt7e2Vl5RtvvJGRkbFlyxZN0/7qr/4qIyPj6tWrv/rVr+bNmzd27NhkMulwOC5evLhly5Z169bV1taeOHFi5syZf/AHf+DxeBRFOXr06K5duwKBwKxZszZt2pSXl2cXbxj3JhKJnTt3btmypaqq6jvf+c6kSZN+/vOfX7x48Xvf+9706dNPnTr14Ycftra2vv7667ZfAaW0trb2vffe6+npWb9+fWp9qa2tff/99xsbGydPnrxx48aJEyd2dHT867/+65o1a3p7e3fv3j127Ng//MM/LCws1HWd5/n+/v733nsvkUh0d3f/5Cc/+f73v19cXLxz584DBw44nc7nnntu6dKlYL8/fPjwJ598Eo/HlyxZ8sILL4CgP3r06EcffdTf3z9x4sTXXnutoqICcyA8FgxGTPVn3E9DJPKEMaoZhinLb38AyhGeEstX9N6ora3VdX3mzJnPPvusJEmCIFy8eDESiSiKIknSuXPntm3b1tnZOX369FdffTUrK2vHjh1NTU0Oh+Odd97RNG39+vWJREKSpNra2o8++mjWrFl9fX379u1bu3btihUr3nzzzfr6+uXLl7/22msul2twcHDXrl0HDx7keX758uVr1671er21tbVvv/32ypUrr1271tbW9r/+1/9qamrasmXLuXPnqqqqXnrppcmTJ9uzcB9//HFdXZ3T6fz5z38eCAQqKyuhSEOE9cOHD+/cuTMWi82fP/+NN95oa2v75S9/WV5e/p//83/u6Oj493//94yMjDfeeOPNN9/s6+v7p3/6JzhsV1fXjh07GhsbFy5cuHHjxtzc3DfffPPkyZN/8id/Yvua8jy/efPmjo6ON954Y8eOHRAv4Sc/+cmmTZtOnDihKMof/MEfFBYWNjY2/su//MszzzxTVFR0H+8a+eqDi1PvseEzSE278tbp+OlWNaqYJiwzgMzv2inzg6brfRFjzxVl89lY56BuMDP+zEMEJKDH4+nu7m5oaKCUwhT2kiVLJEk6f/78jh072tvbe3t7P/300+PHj3s8nlOnTm3fvr2vry8ajdbU1Gzfvt0cZsRiHR0d+/fvr6mpiUaj8Xh869atYGDu6Oj4+OOPGxoaJEmSZfnq1au7d+9WFOXChQuHDh1KdQI+cuTI3r17wWZ/7NixTz75xOFw2B0z2CeOHj0Kxv7jx4+fPXsWrI99fX2wz8DAQGdnJzgVvPfeey0tLT09Pdu2bQPzA6W0v7///fffB0eFEydOfPrppzC5CQ1ZOBz+zW9+09DQoOt6U1PT9u3be3t7GWMffPDBuXPnBgYGLl68uG3bNgjgCBfG83xfX9+77757/fr1QCDw+eeff/LJJ+BZtGXLlkuXLsVisZaWlh07drS0tPT29kLQsdbW1nA4rChKe3s7tJgnT57csWNHT09PIBDYs2fP4cOHYY1/V1fXxx9/fPHiRcMwTp8+3dbWdk9BbJAU2G3+vtyLsIzEMBEE8+YdHR1bt25tbW2NxWLXr1/fvHkzzPw0Njb29PRIktTU1NTZ2QkSBCZz4Ff79u07ceKEpmm1tbWXL192uVyXL1+GCgvFe8eOHUPCpQuC0Nzc/NFHHyWTyStXruzatUuSpP7+fqg1sVjsww8/vHbtWiAQ2Lp1KyxXBa2/ZcuWpqam/v7+7du3d3V1QT6XQCDw/vvv19bWBgKBkydP7ty5Mx6PJ5PJ3t7egwcPfv7557qu19fXX7p0CSaX4FBgnkwmk83NzZqmHT58+NNPP+3t7e3o6Hj33XevXLni8XguXLiwffv2trY2aHmOHDnicrnq6uq2bdvW09NDKb148eL777+v6zpGof7yYYwomqFoRlLX7/lPM1SD6YaR1HTz7047M0U37rWCchzX0dHh8XgmTJgA7oUlJSXf+ta3XnjhBVEU29vbt2/ffuXKlf7+/uPHj3/88ceGYXR1dYHfS3t7e19fH3QH4CvS3d196NAhKMlnzpz59a9/feHCBV3Xjxw5cv78ebfbffDgwT179gwMDPT29u7atevo0aOyLIdCob6+vgMHDsAkVSKR2LZt28mTJ4PBYG1t7ebNmyORiO1m2dnZGY1GeZ5va2uzF4hDh1hbW/vxxx+3trb29PQcOHBgz549paWlYF3q7e2tq6urra3Nzs52uVy9vb1QL6Cj3L9///nz54PB4Oeff378+HGn0wk945AwNQMDAz09PfF4vKOjQ9M0wzCuXr0KVvbr16/39/fzPN/a2trc3AwueThIHpVgA3q3GIyIPL3UqX50MXGtT4spROCozBOOEU1j8KcbjHJE4glH6EDMONOufnBR6Y/qIm/+/KEAvqSyLGdnZwcCgZ07d/7kJz85ceJEfn5+cXFxNBo9depUR0fHxo0bX3/9dcMw9u3bl0wmGxoa+vv7X3jhhW9961sOh+Ps2bN2ZofOzs6pU6euXLmys7PzzJkzLpfrjTfeeOqpp06dOnXhwgWIMhsMBidNmrRo0aJEItHU1ATeq9DgXrhwARzvvv71ryeTyatXr8LUnn21yWQyFAqtXr26srKyu7v72rVrkiSlRpixPV6uX79+5coVr9f7wgsvpKenDw4OgnSor6+vqamZPn36n/zJn5SWlh48eLC7uxsie4A5v66ubtq0af/1v/7XGTNmNDc3g6Y5ceJEYWHhn/7pn86cOfPs2bP19fVg9oYpi/Pnz1+7dm3u3Ll/9md/lpWVdeLEia6urvb2dnBv+Pa3vz1x4sSjR49evXp1/fr1aWlpsiyvX79+woQJYLkUBCESiZw6daqlpeWZZ5557rnnYrHYgQMHoHFnjA0ODq5du7aioqK/vx9Ez8N5/U8Kdm3hCOUJFX7vz2y1vlT5Dl6tLpcLIq+5XK6Ghob29va5c+f++Z//eVpaWl1dna7r2dnZsVisu7sbhLsoiuCCZffNhmH09PQ888wzEyZMCIVCDQ0NPM8fPXq0tbV15syZr732mqIop0+fbm9vtwPXwG8jkcjkyZMXLFgAdVlRFBg5S5J09erV+vp6nudB5YBLPc/zjY2NV65ckWX52Wef9fl80KNTSq9cuXL+/PkpU6b8yZ/8yZgxYw4fPgyn43m+p6dn9uzZc+fOBfdZmFUzDCM9Pf25554TRTEzM/OVV15xOp1Hjx7VNO373//++vXrQU7Bqpu2trYNGzZ8+9vf5jhu7969hmFARKY1a9b8yZ/8SVlZ2bVr13DJx5cPY0zVDVU3eyiDkXv9Y4R0DmqdIc30/DRSvjJ+/5/mFqZa0Rru6fJ0XR8cHPR4PJmZmUkLWZZnzpw5d+5cWZbPnTtXW1s7f/78H/3oR5mZmUeOHOnr61u1ahUs8Hj++eerq6vtTKKUUk3T4vH4ihUrqqqquru7m5qann322SlTpvT09LS1tcXj8UOHDkWj0dUWnZ2dp06dCoVCMKzt6emZNGnSCy+8cO3atRMnThQXF//lX/7ltGnTLl++XF9fbw/CV6xYAX4vGzZsmDdvnt0hEkKOHj3a2dm5bt2673//+7quHzx4ENzbwuHw4cOHm5ubFUWZM2dOahWAWtba2rps2bIJEyb09vaePn3anjobApj8fT7fqlWrXC6XLMuvv/76+PHjc3JyIpFIb2+vIAhtbW1OpzM3N/fuQ8sjIwvUE3ft2s6RtgFtZ22iplOTeSoJZjyZhMo8MilOp8XpXEkGl++nMs8Sqtk4OiWq6OTA9eTBa8mIYog8fVhCA9bWTJ8+3e12Hz9+/K233tq6dev27dsHBgbC4XBLS4vL5Vq1atX69esrKiqampp6e3srKytffvnlTZs2rV69Ojs7OxqN2kbrgoKCjRs3rly5squrKxqNTp069ZVXXlm1alV5ebmmaZDkIjs7++WXX16+fLm9wBRaBE3Txo0b98orr7z44ovr1q2DCADBYNA2MNur419//fUpU6aAQRraPrulA6sez/NNTU0cx02YMOFrX/vamjVroCU1DKOhoUFV1erq6o0bN86dO7e3t7ezs9P+OZyuoKBg8eLFGzZsWLNmjdfrvX79ejQaHT9+/MaNG59++ul4PN7U1GTLIPAmlGV59uzZGzZsmDZtGhyzra1NUZTp06e/8sorzzzzTElJiWEYK1euBOH+3HPPjRs3DgY84Bbc0NBQVFS0du3aDRs2VFZWNjU1BQIBuOZJkya99tprEydOBJvQQ3rzTwzU6m+YTowkUYNEDRC1nyi95p86aG4EQf9lEY1G+/r6ai1kWU5PT3e73RstXnrppezsbEJIOBwuLi4GWyAIdJfLVVRUZC/5gBJbUlLy2muvzZgxg1IKlrPr16+73e41a9a8/PLLVVVVg4ODTU1NkA4d0HXd6/W+/vrrS5cudbvdsGxaFEVYYdLQ0ADVcOPGjatWrYJRMc/zzc3NhmHALP+aNWvgUIyxhoaGZDI5c+ZM8ASDUS4okoKCgldeeWXRokWwJAYyBOu6np6evnbtWkEQMjIyXnnlFRgVQMlfsWJFQUFBXV1dIBBobW11OBzPPPPMCy+8UFlZ2djYGLFgjJWXly9evPill15asWIFTj09FjRr6hcmhe/1j6OkO2x0hw3B8gj93VdWkIbUPa1VTUTVjbsfmXEcF4vF4vE4zO4SQhobG3fv3v3555+fPn16cHCwsbHRMIzly5dv2rSpqqpqYGCgq6trxYoVINzXrl07c+ZMO6oM9DhlZWVgfFFVtbi4+PXXX582bRpMGfX09LS2tpaWlm7cuPH5558vKChobW3t7++H0AtlZWVQj5qamoLBIHhRTps2jRBy7do1O93S0qVLy8rK4vH4888/P2fOHLBVwY1cv37d6/WuXr36hRdeyM/P7+zsDIVCs2bNEgTh0KFDjY2NlZWVVVVVqqqmdoK6rldUVHzta19bunSp1+vt7OyElay3TI0MQWxWrFgBa2e/8Y1vFBYWVlRUgMcspbS5uTnbwh7PIKMM9HG/KyghSZXtqoufblEdAtGtrkfimSTRacVCZY6gamYTltTYlW71Wp+R1ExZb3oDMmP75WS+n180hmdWOJqHtWZu2bJlTU1N58+fB3/u5ubmwsLCrKwsqPC1tbXp6elQ7QOBwPz580Gednd3w1Ae1pvruj5hwoSJEyfyPB8KhSilVVVVkiSNGzfutddeKykpSSQSsNSsuLgYAs5A+BdQ25qmrV69WlXVjo6OeDwO9nUw1EH3DAuGxo0bl56eXllZKYqiYpGa4dlewBoIBAghEydOzM7OnjBhgsfjgeV0gUBAEISenp6jR49CiI/BwUG4Bjs2zrlz5959993p06dv2rRJlmUIeRsOh48cORIKhcASmWoXAQNkW1vbwYMHIXJILBaDE1VVVYmiOGXKlNdff720tNTOtgPDGNvtWFGU3t7e6urqjIwMv99fXl5eV1cHwQ10XZ84caLf76+srJQkqaenBy3u94JBDJ3oMWYkqBYlWogwlTCDMMWsiJyDiFlEziacZOU5e+QPluO41tbWjz/++Ny5c62trTk5ORkZGRMmTIDpFJhYh2AvsKCzo6NjcHAwFot5PJ7c3NzUQHWMsUmTJqWnp1dVVcmyPGiRSCR8Ph8sDZ88eTI4saT6Vum6npmZWVpa6nA4PB4PxMGw48OEw2FN06qrq7OysubMmbN582bwRQkGg5qmTZw4sbS0FHp6uICBgQGITw+1CUI9ejyeZDI5ZsyY3NxcWL/e3d1tZ3OD1Ou2x380Gg2FQpmZmcePH4/H4zD7FAqFoOWpq6sD1wVoeSDp7N69eymlkydPnjlzpp31GflSuaNv+heiM3KXlifTif6uayXoYEVRoKeApL/Hjx/fuXMn6Hi/359IJERRHBgYOHLkCAQi6+/vhzlb6IPsKmbXsqKiooyMjPLycsZYbm5uXl5ecXExtMz9/f2qqhYWFubn54dCoaqqqnPnzkExjsViU6ZMmTx5Ms/zYNhSVfXgwYPt7e2MMdDEcBbwUUk9O0z/BoNBRVFEUWxra4MapOt6V1fX9OnTMzMz29vbFUXZtGmTw+EIhUJDQgnPmjUrKytr1qxZ77//fiKRsKNRDX9i8F/bJK+qqiiKpaWl4EgTDoc7Ozvz8/MzMzNTnwwymkDh/sUYzPR+OdmuHGlWkzqTBbMmKBqryuZXjHOMzRWcItcR0hSdeSR+aoHcEdT2X03UdOgyRw1KBmJsZ21iXI6Y5eF04yFod2gmsrOzv/71r8+aNevSpUtHjx4NBoNnzpxZsGAB6O+3334bVpXFYrGBgYGsrKy33nqroaEhEomEw2FRFO0WITs7G2zbfX19giBAYkWn0zlr1iyHw1FfX28YBkzJSZLk8/lSl82BA+LmzZtbW1shiFVmZuaQq+V53u/3M8b8fv9w/ZoawToQCEiSlJaWpmmaw+FIT08H83xXV5fT6dy/f//hw4dVVQWPW2g3wUyYl5d35coVVVXPnDkzd+7c9evXd3V1SZJ08eLFK1eu2N78MGAAn10IELlnz56DBw9ClLqenp7Ozk6Hw+H3+3Vdd7vds2fPHpJqJ/XKI5FILBbLyMjgeR7C1UOvAFYZv99PCPF6vRDC70Ff+ZMDpUSNkWQr0YJUixOiW9IclokYpnzXB03ru9pJxFziyCfUku+PDOiPI5HIJ598EggEYNllZWVlIpH44IMPLly4EAwGIbqFqqplZWUQAaO1tTWZTJaWlkKMxZSbo2lpaYwxiENKCAmFQhDczeVyGYaRlZWlqurAwEBq4CaI+AYxT1PzoIFugIFlTk6OYRhpaWmg+CmlkCgqKyuLMeZ0OjMzM3t6eqA2uVwu8KOF2tTW1pafnw/LZgRBgLixt5ypBxEQDod1Xe/r6/vlL39JCOnu7vZ4PO3t7RBe45133uF5fmBgIBqNNjc3T5w40ePx1NTUhMPhY8eOrVixYvbs2Y83ifITCKVmMDTVuAdD+BBM17TfF+43kpVYH+Ar46bdXeApfL7LvszpdAqCoGmaoijwT3CVtEeJgiBs3ryZUjo4OBiNRtva2uwKMnwCB8I4mpY1a9oKAkPBZ1gxBUF+RVHkOC4rKysYDMKYEyaXPB7P4OBgMBiUJOnw4cNHjx6NxWLBYPD69etDauUQwPgF/vG/+tWvCCE9PT0Qr2b27NnTpk3bt2+fIAhTp06FxaZDrjk3Nxfc0iCaMFzS3UxPQd9UWFgoSVIwGGxpaUkkEmlpaZmZmTD8uIv3gIwwULh/AYyZTjKhhHHgutIXYQ7RjM4uUDYxT5hdLs4qk7NdXEwlqsFUnaU5hHQXV5nFuyUq8cmado0R4hDI5W79eHNy3WTnw7oqRVFUVa2srMzPzy8qKpJlef/+/XV1dQsWLICIVPn5+YZhlJWVeTwev99/6NChrVu3gpkBemu74+R5XlEU8P+GZhSEZlZWlp24DgIpQgDEIU3JJ598snPnzsLCwqKiov7+/ttd8PAE6cNTt4iiCJ45kiSBSdtepQctrMPhAFt4eXk5DDxA67z88sv79++/fv36gQMHmpubJ02aBA4DaRaEkHHjxlVWVqZ63oN/cEFBAc/zTqdz8uTJJSUljY2NcEYwVGRnZ0PPAU9piKXQvn6YFhhyv/ZjBIfjB37hTwx6nMSbiNJpfqYOwruI4LIcYyxJYKjESBDd8p/R4oQlibOMcE5T3z8y+Q7aPTc3t7S0NDMzc8mSJRkZGTt27NiyZQuldOzYsbFYDHKzZ2dnQ5QYyLMLi9KGHw00cWqaJDu/6S0vABzJwK99OKDjQcRDhbUFDfwTDmuv3oMDZmZmulwuQRAmTZoEIRrtQgueNneI2Gg7vsPodOzYsTk5OfCT1JbH7XZ7PJ7KysrXXnvtxIkT165du3DhQiQSGTt2rNfrRaP7lwm4uzwILtEM9AhtP2MkoZoBauxvOWoGkxFFK1IDIfy9nAw8P2VZ7uvrgzHwU089VVJSsm3btt7eXq/XC4UzPz8fXFmcTqedcQkYUpbsNhxaYDB7w+fUZExQ2u36YmPvTAjJzc2FEO/Tp0+3847dTXNRWFiYTCYrKysdDkdWVhZUwDv/Fgz8sBDl7p+e/QS8Xi8EhWxubhYEITs7W5Zle7oYGWWgcL8r7/aLnerFTk3giK6biZYK/dySsVJBOh9MMLfAdIOkO836IVCSVA2O0jllDofI9cejzf0Gx5k2+0PXlXnlUoabf/AOC/ITnThxoqioaPz48dXV1YZhHDhwIJFIQH5ETdN+8IMfOJ1OcD5xu91nzpzx+Xzf+ta3SkpKfvKTn0Asmhs3aHXwhJDMzExFUYLBICzCO336dG5ubqrYhQbCbvsgUMbp06eLioq+/e1vl5eX/83f/M3t+uMhzQdMj0KAeUhDwxjLyclJJpPt7e3JZLK7u7u3txe8fcBysG7dupkzZwYCgWg0mpGRYR8qGo3OmjWroKDg3LlzBw8ehHjABQUFsAZow4YNMHuYnp5uGyfAu0YUxRdffLGqqgpm+YuKii5evAhLaV0uVygUqq2tzc3NBRMpJIECKykAaTXA5cYwDEjBk5aWlhoo4A4J+ZBbQCnRIiTRalrZpSLizCOc+Hv+MKbDjE6YRpR+kmgmsQbGuamz+FFekTkwy87OfvXVV8FlHPITnTp1ijH2wgsvrFmz5u///u+bmprAUlhQUBAKhS5evKiq6pgxY245VZ3q2AppiSORSDKZ9Hq9UJzS0tKG1CO7kg7ZKAgCBI6AqNJ9fX2qqoI9Lz09XVXV/v5+WZYVRQkEAiAdoDatXr167ty5AwMDkUgkLy8Prt9WQnfOIunxeCCS1Te/+U2YNIBxMkwvfO973/N6veDMlp2dnUgknnnmmTFjxpw4ceLzzz9vbGzs6OiARd5odB8pMMLS3ZYFxywARNVJd5glwRnUhApWSIY8H+Vu2iju9dXm5ORct5gxY8bUqVMDgcBHH32kqmp2djbM/7zxxhvp6emhUCiZTPp8PhiOQn8kiuLwQa8tlO1SDQU4LS0NHMwgJVlfX5/P53O73YODgzdu1uogID3CqlWrnnrqqXA4nEgknE7ncPNTKrBmFFKY/fCHPzQMIxQKQevR399fW1sLgdtrampgudfvPWHGYGI5GAyCu7/b7b5zHbEH2+AKz/M8ZFqFHCklJSXoJzOKwdHYnWAQuF1hx5uVQMwwI7IbeppMFoyRc328bpCklRxV4InIUXPhjhnC1myz4hrLTxOWVkleyfQO5Alp6NNq2pSHcElWRY1Go2+99daHH34IORrsbtLpdPp8PlVV3W53QUFBV1fX+fPnQbk6nc558+alp6cPnz4DRZ6VlWUYBizibGxs/B//438cOnRo+KRe6mUEg8FkMun3+xctWgQS5wuvH0LiyLIcCAR6enqi0WhHR4d9AZIknTlz5uDBg/v374eFNZTSrKwsXddFUYTA0idPnuzr67PdCpubm3ft2mUYxqZNm5YsWQL+uOnp6dBY5+XlOZ3OM2fOQJI5++Jzc3OTySQhpLi4OJFIHDt2rK+vDzY2NzdzHFdfX//f//t/P3HihCAI4C4Pjzr1LnJzcyGKTjAYbG1thWWLaEp8IJhm/hFKRDfhZGJWHcvQB3+miBdNE7ucaxrjtQiJXTM94B9lOwYLuJ966qkJEyZAGi8IXSqKYnV1dXFxcarhfPz48T09PWfOnOF5Htaq3sFures6ZAaIRqNNTU08z0McmPT09LvRtVBrMjMzBUGAOFEXL16EheNgEYfsZqFQCIJFgpSBai4IQkFBASHk5MmT3d3dd9nBwxmdTmdaWhrkXc/KympsbDx9+jRsVBQFWp7u7u7Tp09Ho9H6+vrdu3fn5OS8/vrrkyZNgpghqCe+UnyhXYEx4pOpT6YGMzs43SB9Ub0nYvRHjD7zT+8Kmv9Utft8r4yxiRMnSpJ07NixlpYWp9N58uTJ1tZWn8+XlZUFi50URSktLY1Go2fOnOnt7QW1qqoq+LTcTasLNS49Pd3lcnV1dfX19SWTyevXr2dkZDidTqhx0K2AbjYMIxgMQoaympqahoaGO7jK2GZvt9sNDj+lpaXd3d1nz55NJpOXL1/u7+8Hb3vw1B/SBTPGzpw5o+v65cuXBwYGYLbqznnK7Ik4cKoRBKG0tBRCPNnCHc3toxW0uN8JxogskOt9+rl2TeTM1HEcT6cWCxXZAuWIaq5Avbm45OZPKKGhpN4TNQV9aaYwrVg4eE0VeZpQyZFmbcEYZvaeD3pVpm1P1/VLly69/fbbOTk5ly5disfj+fn5GRkZeXl59fX1W7ZsKSws3L9/fyKRmDZtGkSN+PTTTzs7OyFVk526GbpzwzBKS0tFUbx06dIvfvGLxsZGULqyLIOPIJwaMjPb/jOQ5zkcDu/cufPy5cvgcpPa1vA8D6eAhgY+gwNiIpHYunUrx3GQ8dQwjHHjxkHg53feeaenp8fj8YBNEZLM7dmzJxqN1tbWHj9+fOzYsXZKuXA4/P777zc1NUUiEQhs53a7wdv45MmT6enpnZ2dn3322UsvvTR27Fjw5meMjRs3bs+ePXv37oW1AZcuXZo5c+aYMWN4nj937tzPf/7zK1eutLW1UUrB2765ufnDDz+ERPGwQiAtLa2oqOjIkSPvvPOOKIrNzc15eXmglobcMrrK3DWUKQMk0UddRUQLmKvhOIep1M1axVvmds0KKWNZ13SF9V8kriKSscD6rSXrh3HrrXd/QdYbtBOkw/y72+0G0XDy5MmamprOzk6XywWVaMyYMYlEAiyF6enpqd28Xd3gsHaS84KCgqtXr3744YenTp26du0alF7bC3xIEYJf2TULnAdkWb5+/frPfvazS5cuQSpW0A2U0oaGhp/97GcQeQaOA7Vp//79ELz1888/HzduHHjPp55luA8utAOKouTk5MCqkg8++IBSunfv3szMzOeee66goKCmpub9998vLi4+dOhQX1/f6tWrjx49+sEHH4RCoUmTJg0MDKiqmpGRkeojhzxi2J3FOXjRfOHiK4k3DwHdHSNE0VlcYeZksiWYzYA11ErJeu/1DbTylClTJElqbW397W9/m5aWVl9f39/fv2TJEq/XW1BQwBjbvn17e3v7qVOn6urqxo0bB9ObHMd9/PHHgiBMmzYNfMlSaxl8tld9gAdmZmZmdnZ2e3v7f/zHf1BKu7u7Z8yYkZWVBYZqOw5BSUlJWlrawYMHZVlubW09evTo2rVrU1tyqIB2wCiw6bjd7sLCwoaGhvfff7+0tHTfvn3hcPiZZ565cOFCPB5fuXLlxYsXIfxrfn4+HAEO5XA4rl69+q//+q8QzSkjI8Pj8Zh5r26ewm4E4FeGYcCasUgk8tZbbz333HMTJ06EFLDhcDgnJwdC7mAtG62gcL8TUOovdal9EcMt0aRGCtP5KUUSzxNFN9s7j/x7Q1rGSDhp9MaMUMI0Pks8nVokXenRusNEFEh9r9ES0Cqzxd/NMd7HJVlmA7/fv3bt2g8//HDz5s1utzsej5eVlU2aNAmsgBBixefzRaPRRYsWFRQUjBkzpqam5ic/+UlGRoaiKOFwmDGWTCYHBgbA8KzremFhYXV19eHDh3/+859TSmfOnFldXZ1MJiG5EjSvwWAQlrqDcElPT6+oqDh8+PD//t//Oy8vD4JLpGZfglAtoEI0TRscHIxEIrIsV1ZWHjhwYMeOHX6/HxYDJZPJsrKy1atXHz9+HHLRwbJaENkTJ048ePAgJIoqLi7Ozs62Jwqzs7MFQdi1a9eFCxd6enoqKyuLi4vz8vJmzpx54MCBpqYmRVG8Xi8kfwZPG13XwVEe0m0EAoGpU6dmZGSkpaXNmDHj5MmTtbW1HMfNnz8f5jTHjRt38uTJrVu3QnAAWHjncrlmzpxZW1u7ZcsWnue9Xu/ChQs9Hg9ctn3LcEZsQO8OSrQwiVw2Temij0hZxJFJBLdlZRdM4W6o5ld6gsR7WbCVBC4R0XNnpQCr5e7bVwneIMwsKYpi5yQaP378yZMnf/Ob3/j9fgimBLohNzfX5/MlEonCwkKIbXfjMqx9oLpBFYZYLjzPz5o16+LFi/v27UskEunp6cuXL8/Ly0sN3JRahEKhEHgFRKPRYDAYi8UmTJgwduzYCxcu/PKXvwRv9cHBQUVRiouLx48ff/ny5TfffLOsrMzlcvX392uaVlVVNXny5M8///zixYvRaDQ/Pz8vLy8YDA4MDEBgKMZYKBRSVTVVu4P10ev1apqWlpY2e/bshoaGN998E5avwEL26dOnnzhx4r333oOWZ86cOWlpaTk5OfF4/L333tu3b19/f/+UKVPAV/h+Xwhy94CI5qxxLyXk1pEBIRz7F2YaCSUYz1OnaK5AFTiS4+XcEgPFDx2fU6bmQe5r8sswjMLCwjlz5hw5cmTbtm26rrtcrrKysgULFhiGMXny5IqKir179548eTIUCo0dOzYvL09V1bFjxx49enTHjh3Z2dmzZs0COw50WPBZUZSBgQHw89Y0Ddptt9s9f/789y00TcvLy6uurrbbbYizFIlEKioqqqurDx061NzcDEEIysrKUsst7A92enBFgxPNnj27pqbmo48+cjgcwWBw+fLlg4ODBw4ckGX56aefjsVin1q8+uqr4XA4EAhALxkMBgsLC7ds2cIYy8vLmzFjhiAI0Wg0EAhA+j+7F45EIjDBDiP8xsbG3/zmNxMnTnzqqacyMzOzsrLAldTr9eIS8FEMCvc7wXMknGSXOlTebKEMnhgT85zpTk4zzObJKdIMJ2+vqafUtEN0RrSYaprVzVgYjKS56NQi8dPLCs/RcEI/16aOz5VUy1H+voEMbStWrLh06RKkfVZVddmyZdOnT4/FYrNmzbp69SpkP5k4ceKmTZsgQMrJkycDgcDMmTODwSBkVpIkye/3g7yA0DHPP/98R0cHTEQ+/fTTlZWVZ8+eTUtLczgccGqQGnZzAFEpGxsbA4HA0qVLDx486HQ6U73nHQ6Hz+ezkyX5fD6Xy6Xr+qpVq+rr6wcHBxcsWJBIJC5fvgzGvGeffTYrKyscDs+YMePf/u3fIIx0UVHRunXrQFjk5eW99NJLJSUloKJ0XS8uLl6/fv3mzZsTiYTf71+1alVpaSljbP369Z2dnX19fS6Xa82aNdOnTw8EAjBOgH7ihRde2Lx5czgcLioqeuGFFwoKCgzDWL9+PWRChVsrLS1NJBJTp04tLS0VBMHtdkOQHIfDoev6/Pnzm5ubDx8+DOtfly1bxnEcPFW4ZUEQfD4fGGsfvDSOdkydYTrJJq6zSAuR8omUTZwZRHBRTjIjqVKOMMp0halJOniVBRqoHKEiZwr6O9am+370sGAaygwEXYYVpfF4fOHChWfOnKmvr588ebLL5Tp79iy8cb/fn5aW1tzcXFZWZmfqhUPZ1c2uC16vN5lMQoU9dOhQLBarrKxcvXo1RNgADQ1FyO12QxEC6UwpdTqdYHJLT09ftmzZwMCA0+lcs2bNsWPHINKrx+NZs2bN4OCg0+lctmxZR0fH1atXDcPIycl57rnnIN5UTk7OSy+9VFZWdubMGUhWYHuxDzHXUUq9Xi94txuG8fTTT7e2tp49e1ZV1RkzZqxevTqRSMyYMWPZsmWffvqpYRjjx49/9dVXdV2vrq5+9tlnwcCfn5//0ksvybKM3rdfCvCEGWFm5MRbNkGUEI2R7pCR6eGc4u0zfDPSETJ8DuqWzL5P5ElpuukpCrof4DhziZcZfObGm70H2ztME7388suQUgBcX1avXj1u3LhoNFpVVbVy5cpkMhkOhwsLCyFzQiKRmDhx4rhx40KhEDgo2l4u0D7blXf45+XLlzc0NNTV1WmaNm/evIULF2qaBqEnIfiMrutpaWkrV67s6+vr6OgQRRFSOKVGi7croH1wt9udTCarq6uhOsfj8XHjxr366quQabu6uhoyMYFJPh6Pe71eCG4GveSyZcscDkdzc/PUqVMXLlyYTCZdLhd0JRDOFebJPR4PeNKrqjp//vzGxkaO45xOJziI5uXl1dbWpkZiQEYlZlpKMooA1wsIL/WAaokR03O9oU/9/3wcjGqmmTmdi35tQXaOj1cNInKk0C9kOG66t1oqP5hgTQEz0wXUGljY2h7Q3z0VCys0qbMlY6Q/f9rDTBPIg87gE0LaLaLRaG5ublFRESxHE0Wxv7+/o6MjGo3m5eUVFRVBVNrW1lZo+DRNg/i1oVCoq6srNzcX5vTBLNHW1tbf3+90OouLi9PS0oLBYHt7u8/nKygoUFW1tbWVEFJYWAgyheO4RCIBNomysjKwH8C34Efb3d0dCATy8vLS0tKi0WhraytMfaqq2tDQEAqFiouLGWPhcLikpKS9vb2+vr6kpGTWrFldXV0/+tGPSktL//zP/zwrKysUCnV0dPT396elpZWWlkI7ZfsMRCKR1tbWYDDo8/lKSkpAmuu6DtnXnU4nzHsmEonGxka3252fnw9Re9va2kDNl5WVwSI/VVXb29v7+/vdbndJSQnoJE3TOjo6wIzKcVxLSwvMt0Jwsc7OTl3Xcy0opX19fT09PcXFxT6fD0LqulyuwsLCEeH7DqoUFhre4YLBZhyNRiE6+EM6OTMt64PHSOOPSVJnhkyYRJjIDN70dDcVpUiYTNQooTplEconqSNJcpaS0j81I8+woYFlzCppjqWtcK7CPet3kNfwBsGhZUhMIch2np2dLYpiKBTKzs4uLCwcHBz8q7/6q9bW1r/+679euHChHXBdEIT+/v7u7m7wp4IgjJIkFRcXQ/DEzs7ORCKRnZ1dUFBgR7qAqfDOzk5wHLeXoID7bCQSKSgo8Pl84CQWj8fLy8sHBgYg8YLT6YzH4y0tLYqiFBQUQAjU4uJil8sVi8UgUbzf74eYlaFQqLW1NSsrKzs7W1GUjo4OwzBKSkpsNwNVVVtaWuxATJTS3t7ejo4OVVWLiory8/N1XRcEYWBgoKOjIxKJ5ObmQuRsjuPs5igrK6ukpOTBW+ZRAKU0FAqBIeAOTwPiEIAyu5cGxFycZU5SGRrRYkQLMC0U5ws16hxeDRihu2qTWR5uTqlwu6lgxti5Ni3Dw43JNPu+G0mYbrrN3BgiwFIUw+wHXbLA32MPB/NLLS0tkAcwOzu7rKwMml+oX52dnYFAID09vaSkRJZlCHTW3d0NVS8zMxOiIQUCgd7e3oyMjJycnMHBwY6OjrS0tIKCAgjSmp6enpubCzFMYWlHfn4+hEwdHByE8OcZGRmapgmCkEwmu7q6enp6ZFkuKSlJT09PXQLb3d0dDAZLS0shkkFnZ6fP58vLy4MC39nZad8FXEZ6enphYWE0GoV8fEVFRd3d3YqiVFVV9fT0DAwMFBYW9vX1gaNLXl4epRQUf1FREfT1Ho+nsLAQoj3CQ0gkEl1dXeAlW1RU1NPT8+Mf/7ihoeHP/uzPFixYgBZ3ejONLvjiklEECvcvEO77r8T/cc+gQHVdUacUS8/PyhQ5Kgmcz0GzXbxwc16QoySYZP1RPWyuSzEzp5qWeGveUDPY9vPxs+06x9GyDO4vl3qK0gXVstnf/7VZvSkkp4jFYunp6YqiwFSdYRgQjxk8zmFhuyiKIGfBywVib0E+l0gkYk+RgyEwmUxKkgRHhrjmiUQCkkJDADg4pm3hcDrNMJeqqoI9A7xlwDLn8XggaAYk0fD7/WA4Aes1WPXAQTCZTB49evSf//mfp0+fvmjRogsXLvz6179+7rnn/uiP/gg8/DweTyKRgBBXqU2SHSUmkUg4HI64BdhH4V4g61MsFhMEAcY2EB5elmWn0wnpteGYMAywnwBkurEPBTIO4hJEo9FYLMYYg64X+oxQKARb3G43OFdIkuT1elVVheD65CvPV0C4HyfN/4OoGtN0cxpeZ2bYOc1KAMMEookskSQORnme+iQqxUnGQlL2F8OFO2OE5+lgzNh3NVmVLUwpEMBAeG8XxBhE6FcUZfgb9Hq9UMhht3g83tDQcPz48ffff1+SpB//+McwL2QvCIGCAdVNEARIFzA4OAhWNLsUQeG0g2AMKUIQEwPyw0uSBEE2HBZmWntVhWUn4FEjSZLD4YAITpDdJhgMqqoKx4zH43DZUK2gVEejUagCkJM4NXIFZHiwazf44MLoHa4N7lGSJKhTUB2gRkAdtJujEVEXRrJwp8xQiRqgRowYcaIEmJ6IOp8yeJ8t3O3/E3i6szZ5tVf/1myH21p+OvzdMMZOtWhZHq4q+6Zwv2E7sj5ZGRbM9IJW2CfuvoS73aPF43G7R4OW3I4XCUUoGo1CxwGFEFpv8CWD1V/gOxqJRMCSHY/Hw+EwGNRhOyEEah8cHLY4nU6v1xsOh+3l3XYnJYoirEdPXesJXRu4skArAV0bFHiYNIPA6rIsw2VA/CW7ckGtByORy+WCdMhQj+A4Pp9PlmVI6ge9Ujgc9vv9kDQNhjQwGQg5Ew4dOrRz507G2N///d+DdewJr2gUhfuTKtzJz49EPzwbpLEBSsimp0tnVThFzpwx9DsIn9J4JXXSNqiFk2bwR1jEQ6npO2gw4pLImSblwwtJQqkskD9d4lkwRjZX9jxYnYIwtCAroS9MDTNnr3MH85gds9b+Lczj67qemlc5dTc4oL0FVsaAySE1KiIIF/t0w7+FocKQQ5ljm5SKBDK6q6vrxz/+cXt7O6wicjqdX//611evXg2S2m5nUzNFDzlL6rf284EuwV51ZN/LnX81fKMdzR1CQ8JXqV6P9mHB+pj62EfK+tSvgHA/Spr+B9GtwDLWqUxLXswK1G7+MRbniGRNyDspkRMkezEt/fPhwt1gxCnR0y3KP+6LvjHbuWKcrN6XW/Xt3uCQAgye35s3b/7pT3/qdruXLFnyne98B2b87UqXWt2GHDa1FA2J93y7Cgjh26F2D6+DqdtBW8OH1NYgtZDbAU/tajKkIg9/DsNL/pA6ZfvUDW+O7udNjC4etcWdJbpIrJGSuDmEVRXGO2Lu6TrntRU7Z9mVDIPwPGkZMP7tSHzdJGlBhZjUby3cz7RpGa4bwp0xklTpjTJnHVEWzNWrMGA28x/JPH/DLP9wejQ7T+qQZhm2p/YIt+xxoLO7m3Z7SG+Yul5rSKeTWgFvWZ3tAg9b7I7P7krg4uHa4JrtkmD/Ck6ReoTh52WMuVyu7du3//M//3NaWtqsWbP++I//GOe1yKgW7ujjflvM5TwGawwYhKN6Iu7PTJ9U6Cjy8hxHzRh1Nw0K1m6kM6xFFcP0wk1pFhWDqgbhdZbv5/wuOhhjMYUOxB9Oqhhoj+ywUKlf2f+02xp751SGK+Dhuw3ZcsuD3PLz8FOkHmrINUMrlpOT8/Wvf/23v/1tV1dXVlbWkiVLFi9ebLvEwG9vGd/KPkvqt7e85dQtd/7VHQ5lB4VMfdRfeMvIXaEnrUAV9oJSZv6/btn0dGsWi9eJRsw5fzOg9G0dYKxhM2seMHMvlGYI5iT+fYWXud0bvGWlg/wp48ePf/bZZ4dHfb5DwbjDuO52FTD1J7erg7cLBje8kEPsmuFnucNzuOU137JODW+OkEcJx/RBmmgw13BzjGiaOYrlh3vI3KxbOsn2cNkeerhRnVYoiClJT1PXODglTuLNuGqUWOEgI3pcNSeWIaNqro/LdJvf/l58tYfXo9klZ0izfJfNL4j+u2+373D8Wx7hdtXZPmBqxze8Cg8/9fBT3LLiw9Hs/GsQ9WH9+vWyLKO5fXSDquLWgJeLGSImYvmESM6KfHdxuuAQLMFuNVh2oPe4xkLJm3IDJIK1F0eYyFFFJz4nn+niBmOGqrP+iK7pZuCsh8Wdo72OIHier66uBtdwiKvl8Xgw6vPoZZjotpK7sDCjbnbDkwyWfcN4mLeSqkNqdcOqgwlCYoz+/uQ/mO45ShIqu9SlF/r5HM+tHQAeIrDYo7q6Ojc3Nzs7u6SkZJQZeJARgplqhCa7iB61+h+r8hDdTBx4Q1WbdliBp60B3SnRPC9ljLokUl0q/fZ04kybtqhCZJwZiNVc2KCb0hzqZb6XgnCHf7pkylsBIs16Sc04DTcv4CF0baOmR/tyANU+Y8aMTIuysjJsfEY9KNxvC8eRvogRS5q+6QYvjc+X/TJnmIEthu6p6Ew3GG8Fehd4Mz+7wcyNlBKZY1GNOAUuzckRYlBCukNaTDFkkXtYE1mjpo0Dm8G8efPAE8B2MX/c14U8IribktxS4pASlelEsfIzilbjZOVfIpKpPcxiboZLuSHZzWqYNOseVCtzwAy+t9Yfz5G+sNHYp88rF50Sd+dQdw8OLN8cM2bM1KlTISUKenIjjwkrrzCDEJBWeHYzauPvOYpRSgbjrK5HH5/D8ZZnlkMwZfqhBjXdRR0i1Q0iCzTTQ2XL5YUQYvVfN7osc3/RDPJEmBlhJs1hGulv+Lg/jBvAinOv6LpeXl4+ceJEVVWx8XkSQOF+G6wUcX0RQ9EtS4Vh5PoEgaeadgvbHc9RWaACx0EgC0oo5KcglDKDaQZVGHVKlCOmH1t32AgnmVMy43Bh3UrFjm9tO+yiah/VGGbSU1NSGOa0PkuaWZZIkMiERSzJLpl/5jZzPt7U7kz5nXA3ZTpPqGyuWtUNcy0rqHOeN2uuSEhLwEhorCKTF3mqag8UgPVuoJQmEglY520nKUOQx1OtDGuVKGhpyg1ZKcoYS3fRXXXatR7Tdm6mw1NMOX6tT//wguKRTN80v4NfNV7M9VGYSrZypt6wWTFiTmfFVaYb5koSj3zz4NayLuTLh1IKi3qx8XlCQOF+aywfGBqIGbpBmaHLbrcgiopuQJQYCNN+c+qRSBzNcgmwGjWssITGEroRVc0UqQJHZd7QdCpJ5nodjmPBpBFXmfkd2CiQFGDBjb069nFfDvLoMMxcS0o/0SPWVH7S/KM8SXRQS0kQxfxjSSsjIxjzdDOHjOnpfiPSKiUuU6EnNCNuBqFhqm7OsEsCFSjjCT3foaY5aVnml7dIC0ss8vix1oda5vabMtv02jS1+w2TuZU1KdfH8Rw71ap7ZFOOM4NoBlE0drVXFzlz3jjHwxRdpOxG7YurzCGYPjbQ64kcMQRT01NGIknmFKnAWbmcsE97TGDj80SBwv22UGo2SbrB9GTC55ISjI+rxC2Y0twtmvFhbD0g8abRPZrUdUaSGlF1Q+CpR6KaYWiGuUzVL9PiNHMhOKeRqKnsH/OtfZXBBuiJQAmQRAvRBi3XFskUAxxPOMt2xzPqombLpN1Q6qaIN0Ng3FyzSimVCeENTuISXE5IFRWiG2b0SMaoOZHFU1OFXO5S8/1cro/7wnTuDxEsvcjjhjKWErrH9CFjlvX9xr/MqkZJUjEnqUrS+Hy/6bSZ1Fl9j55UWa6XFvo4l8zl+TivFR0SCMSZT6ZpzhvH0wxmxoVkZnVTE2aOcDsyMvK4wMbnyQGF+52Ia0TXDaYkRIeu6IZmWN64MHF/E2buxgYTejhuzhOCt4zI0Vw3MQzaH2c6o7luM2m7aa0wDEUXVA0rGPIkY5BkJ0l2ENFHhDTCuQgnWs64DhK7YtkIKZEJkQnVLflura8z/XVvancqE8ppmlQWlmfEddE0ylu+bWb1tCbEGgb0vqgxu0x0ilTVvjzhjiCPGcoTlhILxRy2WlobwipZHwWedAaZW+KWjBEK08xFpl1hvb5H9zm4JZXSuGzeIVG/ixOsCgUMxg2OcOmuG1KecoQzw62ZVZOz7Ps31q0+lltGkCcMFO63hVor30zPDcYMRRGYmRJVNYhXppZSuLmPQXoiesSK4E4YSVrNWUxhfi/nFrm4phHKOQTqkTnedLrRGJGs1vBJj7GKPJEwU1ioUab2mW63Ui6Rsi039ptx3Kn0eyrbzJVAiMtU8IbCmbGjCSOqFYPO4Q77V0Y908yM7jerk7k+3FLwdV0qx3FV2SJDp1vkCcKakBJkolg63eylrD/DnOS9kRXwxqItUl0iTM7jJcGsbm2DLK4ac0uleWWSU7aWeFlJz0ynG87sBJMqUyVzoQgEUvM7OGaPoiF0zc35MKhw9xd9FUGQuwGF+x0B/z7ODERHKQ2rTDTDYFDRmtIHf8GkxiKKaWs3dzJbRVM7qAaLmmFuqUPgslycapCExswF/Bx/M5IkgjyZUEONEC1q9utqmIjppl6/kY2Rt1zab9HnM44xnSO8lUvVVApM8UyKeeYS3kGZZpgrVS0vAMugqBqsoU93ijTdxSd1JjxgqjMEGUlQwss3K5TlFmN2SxaW8Z1Qouksz0cLON4pUrPCGeRKr+5z0EWVot9JNXMhKjEgjhNocGYa2g1rgTe40JsxGHhqZhs0MTeaPqHWV+bxGYGFKgiCPApQuH8RHEcFgbAEY+Y6+iRPo6rhEnnppktfQjMtfhA1i5n+7lQwWy5TnSd15pU5n0y6o6bTLVOTxFzdik0a8iTDEbWfhK8TVzFRB0mcI7zTlOzU8nFPRswgj87fn5HiCFGskBZQdXhCeDHqm6dKORxTIOS7Xal4jgzGSE/YKM0UDEIiCklzPI67RJDHA2f6ntnwAjEUcjPNKdQq3SA+hznjpWim28xgnF3rM+aUimOy+KRmzVlBCHir5sGv/E7OKZqjZkhLHEwwVWMcZ1Y3wojA3YhOg1PJCPIlgML9jlixHa0YV1Z7xkwjupkVNcVfENoyW1SIHOEp5TmW7jCtFD6ZJDRzN5EnRjLBDAniTCPIk4glCjgjyEI1pnnOkWPGlqEC4QTCi4R3skSAxK2Zd95SDVZtoaaTmenXblYzkRBd0xwlcc9kM1+CFbzdMhqau1sjZ9I2aESSbEIerxoskjSXhqOPO/KkQCnjXGaJv9FL3TC933BiuRn1RTFuWuTNwKm6RyaLK82g7eba7psR08CODhUsx8NJvKn4oRLHFBZNmieQBcpTU/07zZ7thgcp1ESscwjyiEDhflvMVomn1NA1JUmcvBlTnDFBIGkOTjA/3tzt5gfI/6wZ5hyjbvAOwVxKJ1Aa1kyvW0U1dE7iRIka2k3jIdomkCcQK7EpjbKBY0wuYp5Syrmt6OsSFRyERolBjEFCXdbiVMFalqpb42ORNxeqUkoUPeaaoYlZppw3PdOIzsxVrJbaN8NFtgyY6WaK0nhKWVJnCqMO0wEHhQTyRGBOEXMC0VXLbSVper1ILs0gpo3cigx5M9+IKcSTjNR1a9XFYp73RoJhiOpo+peZaQTN/TlCXGYeEkvKW1/5ndQlmVXP/NZU/zdUO7Mmn3UUFgjyKMH6dVsYIS5eI2qcMEMRvIa1hE7TiSybmSiGiG6zEYRpRNMLl3GU8RwJxgkvM4k3JUdbnBmcSBgvElU0ZYb4mG4LQR47ZlJ1avSzpEqNICEOYvBM5ZjGE2GAc1MWJyxOSOKm0Z2ZKWXMBEwJy2yoiEl5jGmBNxKE48z40zpxCDfCRcYV1jSgF/jNYHamziBE1YjDMgciyGgHxqfCjTTCAM8TXTPlNUdNbW5ZjRRYj2WtUi3J4CuzBSvIoxWMgVLDYIaVqwQM96YQt8zwEFLGlPuaOZdlpk11memdOO5G7buRngRNUgjyKEHhfie8DnNJPdXVuGooqs6okNRIRDW8KTrAjl9r5oThiKoT1cwXbSQ1TtVNSWElVSV9Ec2MaGcYHgd1CNiyIU8ylnoQJcoSRGk2V51q1MyWGmE0nSeZ5mpVFraCuKs3d1c4ohEWp1TXdMmvOzLAgM4Rc9b+er/+VL4Zu5pyNBAxOkP601WSwJtJFRghMZV4pMd9xwjypWHmH7sZqYkXTD+ypAJBG61pY/MLw9ToZodFKZlaIAq8aZMyczMx00kNcpyxm0tbCSHRJOM4JvFm5kDDkvhJzazFKYmdbkwio5MMgjxqMGvCrbFCrrOsNKckikYspIYGgpGEQSjPmTErbJdZSolToGaoGZhDNF1lqGJwmk4CccMjmTo+aQWi7gkqqmboupHplzxO3sAUc8gTjum3TokgUomnTo5zctTFm74xVsRIzk+4TMKlWz4zAjX/OGsanmmGL9NwZZgOAFYQi7jCTjYrPRHDnPUitDPEkhorzTAlhmZQ3Upm/KUlT0WQxwpYvHnC2yuyGdF1wvG6YWg3IjKZql3gzDgKZgQaK0YTREizV6NynOm5bv7U7NdM63132AjEbvRZlCNemcvzcn6nmbzJ1O1WvBrTx8YM2Pq76O8IgjwK0OJ+a0y7gkFyPLykxww1SSR3V0BRVT0jTbQd3OG/skDTnHx/zFy3o1gZmkyVQElMIyLPgkmS6zIFxGAkqStJQ3DmeHmPbLZ3qNuRJ1VacDdSKd38t/n/oun88rt6cXOFnDkTLxDDTJ1g1jlKDN2daUh+apgyRGPUKVJFI00DRnG6kNBYY78Z2C7TTc2cx4xKHIlp5ocbB0CQUY9pbrdGwMTyZ7ccWai14EozzOWmIOCtBMOm1zv4t4BzjWWXN9Gs2I4Qn50xFk4a5tIU0zJlbh+MG2Ez0JrpF+pzcFDdBN4M+25uxL4NQR4laHG/LQYjGU7qEjQiOSnPt/bEHTz1SJzM33B0uRGbjpJsNyeLXELnbmSVs9q7hEZ4jnqtiBaBiNIXuSFVslxmPia0SSBPLgbPYpSo4MIO4RytuDDsRobUoalciJWaycrOxDkMXfYbnEu38i7pjLjN9Ox8a8DcW9NZU69alMZ7HDSpWz67lMiQxQlBngjA4u783cDY7JB4c03pzVoAC0+ttVg3eiv4Bv5rGc3hQDcyrjJCkqrp2g5Rj6mp6c1+TeDNPg4OYv6BMQsWtiII8shA4X5bGDFDXOWlO6nk5ojR2x8mzNCsDDA3MjXejN0u8tQvc7phruYxw9JZTZhgedHkuqhTpp2DSneU5ySHSFi2m/JmgsfHfXsI8pgwDXxJwmKEJYkZKAa8Yg0rIgyzlqWaUWFuxLJjOmGKtZvlg2u63vJOnZrph0FY8BwtTOP6onpUJYE46Y8YpRmCLJir7iglqlUr7dSqCPIkCHfGO3+Xg0nXYVxs+q9bgpuDDErmoiyzMwJtD3+mI42tDCzvF+jvRMH0rgGvd0pJupMWpXHFaVxpBpfuMrW7eRxI9GQpewRBHh0o3G8L5HYem++ixKC6lgyHm3uiEdWcUQQHdc2cizelQzjJfBJ1iEw1CMh3gTMt61GVhZLMKdCOQSOQ5DjK+R00P81cv48gT3C9UqlbN7X7AGEhU6kz9UbWdDOgY5SwiKnXfzftbyYlJkylTKdWeBmqW7sb1qQ/T1mWm4YTxmBUb+rTKE9LMzhdN+ugUzR1xEDCXGqCRnfkScEs65bKhhGruZhU5a2AMppu+qObAdBM7U41nanW1BVYyk3NT4loGczNUI9ghDKzl5AcH2cmVbVqJbjgWCrfcowxzK5QsY5jynfCVN1A7Y4gjw4U7neEkXGFbtHl4XheiUQuXBswbeU3VvKY0WOSuinWg0km8mbqJY1RF88cHBOtxfbhpLlvVKW1rSEtFtQMI9cvFKULZnyaxyQjDDOZ1I0E2GREYWbsvnnxd76FR3F3tzzmF17JI2UkvsSbGFQi1G26vphBHiOEBc0wMqZk183VqEwhRsD8M0PNmGu7zYGyea+qGa2OqCplZkR3y1Rv6pF0txnpriOoX+vV0lw0z2euDh9UzLUlprHQCjX91edRv9D7O/5DuSqouY/u+MhQqGDJd0uMm0kSOE6PWbZyZoWTYQZj+u8eu/lPgzHNMMX3DSlv+cywm7t5HKIs8rAbsSqiqjPd2oO36pc5DDCYZop4a0h9vxc+pDA8yWXjzlXjS6s4d+j7HqTiIw8CCvc7wQgpzpRysr2GIDFCLl/r7eyNCdbq1Bv+f5BygiOqZYMXzCbMnJQULM8/kSNpTq6hO17bFBDM1TusJIPPdHGwNuihCFngLmsRpVSSzMB4vAUZUfA8L0kSpVQQzBXVPM/Dh+FwHHe7r+4bQRCGPzFBECild7iSRwrPW0nBRiTmuNYU7j5CnDdSGpguMVbwR+oxA7tTw/KQiVseNXHCFMNc+q0wohKqJgSigJ8arJbzOWiujzvfrrUO6sXpvEPiwipJWsFYkzrxyqYz7oP4ytj1684V7QH70UddK++voD6UqxLF26atGIlt0QiAk8wcTNYnwpsBiQU9yAjHOB5SphqE08yI7eY8MHitG4TTmTkMtiLEmFXLWkNibieEOllUZHFGON0A/xlzMG3GV6OcudHqB83wDLrpNy+Bt+h9CURqWvFvWsdutvZPJneuGoIg3K79f7iCfvhl3P17EUUR01Y/CkZox/9lYLnEML+Tn1Dg0IgouV19wcT+i/3msnpIRUFNgS5wxC3QaJLxxBA4Fta4iE5VZgZrT3OY7eDZa4H+YJKXPU5JGJvFcQ/J+sdxHNSouxdwjDFN02AcPOKGwoZhqKppcdVNl03zn/BhOPY+DxFd14c/MV3XYfj00E93N9z9gO2rx82RK0+o04r8mE44n/mZWgKPc9/YQiRL0EcJizGiMKaZap5Xg7yRhNVwjJlTXiJHi9P4y51aQiVlmaJqkIhKfZJZFCIKLL97oKl7u37duaI9YBf1qGvl/RXUh3JVdzjvSGyLvvIwalrcRStIk1liKWUSCXF62LSXW/9jzIwnY1nQoSszt1FqynXRWhRCzaWr4PROeKJ61aturRnM7QZjpv+aVfsM0/RuKJo5+WwOAkz/NE68r0Ql1jDCvFqzj7Sq0qNoyUcQd64a0Pvc8quHq5WHX8bdv5c7XCTyIKBwvxO6QVwyP6nYK8gS5/TwGfknG2PXOiIQEpJZBgZCmWGwgbgp5yMqp5hzhXQgQXqjZry6y23R402KGXgrmcz2iU8VOTXLJvGAUEp9Pl9mZmZWVlZ2dnZaWtoXaneO45LJZENDAyGkt7e3p6eH5/kRUakYY4IgdHZ2Xr16VVGU5uZmTdP6+/u7uroEQUi9BbM34rjBwcH29vYhB+Es7u/sPM+3t7f39/fbp6OUaprW3NycTCaDwWBbW9uQK/kS6OjoGBwcHCkv8fdgmiWkb6ZQAtd2annOgGWWuxEd0rTKe614MgKhLmptEQS1l4v3aVaICzPehU4TOud28QIl2V4u2yfoBnHw5vRXTKOqTpi57OQ+HxEY/7xer2zh9Xrv0JXyvLn27/5OJAhCb29vd3f3IzJQ8TwfCoWgXtz9KR78qiilqqo2NDRomjbkIFCzOjo6+vv7R+zc0Vc2lLtk1ZkbcV4Y4QQ97InXCVqIMpXpiqFrPFGoEedYkhgq0WLUSFAjyZMEMRKWr4zpTcNTlTJF0AOO2AVHvE40QgLVBaLw1LShMKYSIyaSqMgx2ZzUYg6BukRTd9/rRRuGIYqiz+fjOM7v90OzFo/Hm5qaRlb7dt8dTSrQkQ0MDHR2dt6y6jHGmpqaotHoLdv/B2mIhpxFEIRuC5hehjGVoihNTU2qqsL0yO0GYLquNzY2Kory4FeCDOHJnYe6SxgjkwodRRlyS48q86SnL/Tp6c7MtPI0p6AoOsTEDSZN4wQjZgQ6gZK4RsJJkuagYlLfe6G3M6jLLleCcE8VCLl+U1U8YJ3iOC6RSHzwwQcDAwNm26mqOTk5ixcvlmUZDOpQdVP9wsFJpru7++233/6zP/uz+vp6XdeLioqSySTMeYFAGdLiwKjaroepR4MtqU7nHMfZB0md7oTZzy88AvwKrMj2t7CDJEnNzc2/+c1vKioqcnJyjh49um7dugMHDiQSie9///vJZBJOBz+XZbmtra2hoSE/Pz/1UOFwmBDidDo5jrNt1bZpZzhD9vn0009zc3M3bNiQSCSgaY7H48eOHVuxYsWZM2caGxv/9E//FL4acmT7lu0ttzv7Fz7e1J9TSs+ePVtUVJSfnw8NKBkpmDmUdJowTI0OVw2r4hixbIA3Y0GCfIdIFy5CNMu+rjIiibzaRxMBw1VBDY2nZmRV3WBZbm7xWDnDQ70yiatE4tlg0qybLpGBkLi/3h/q0Z49e2pqaggh06dPnzt3LnRFQ96sruuhUEiWZXDoso9wh8KWOmfidrsvXbqk63phYaGmacMrwpDKOKTi2AccUmCgGuq67nA4Ll26dOLEiR/+8IeCINiWsOHlKrXqybIMV5WXl6frOnybWrVBNwwp4aklWRCEZDJ58ODBTZs2SZIE8h3qIFzV2bNnMzMz8/Pzk0lzSZB9DXAQeP6GYVjxB80KnvoAh1zwcFJvyr5I+0HZZxnyuFKPMGR/MjJgjBMpzF7dqEuUGJpD62Jqn25EDCIwQxF5jpmTXMT8L2PUCJi3KOYwzsOYTowIoSLHEpoel1iCU3oIF/PQU4aQQY1BQgRVDRJicIbIeScSr4+j5tyXxFORv+enxBiD7unQoUPt7e35+fkrVqzIzc1tb28/dOhQUVERlCvbYeN2deGW5Rn2hA9Dfgikvly7C7tlwRiyj33e1AOGw2HGmMvlSt3BbiLss9+5NFJKRVG8fv16f39/cXGx3a2nTl4dPnx4/vz5mZmZtjK2zxIMBp1OJ7ipDG9/btkipd6gruv2XVNKDx06ZBjGN7/5zWAwaBhGWlpaLBY7ePDg888/L4qirutD3GZisZimaR6PR9O0gwcPrlu3LiMjw67Ld24SkbsEhfudoJQoGiv0cXPK3S0BTQv3MDV55JJemONZ+lSuVbKJwWhcJw6B6opZBnVmetYahMYU1taTPHd9kKdOTXKne1xzSk0TyAMWVKhdiUTinXfeSSQSLpcrGo2OHz9+7ty5TqdTlmWe58GrBCqGJEkcx8E/dV1XFDONZFtbm6ZpoihKkgQtBbjcwG437506HA5zUZOuQ8MBR4OmAZoPSZLszlvTNPC60yxggA5H1jQN9uc4TpbNyPb2MWVZhioNYkWWZTiC3Twxxjwez6VLl+rq6ubPnx+Px+vr61esWKFaQMsiSRIcATqA3t7e69evS5IkCALs5vP5ampqBEGYOXNmLBYTRREM5HDSWz5nOKZhGHAx9gU7HA7GmNPpDAQC9fX18+fP1zRNVVUYYIDLuxlQ/OaReZ6XZdlczmVd7ZAjp6oE+2XBueC+Uh+v/XNBEDRNa2hogNc9sixSJobptk510xMGYj6a9UIkLEGIclO739zTFB7Q4KuMaOZSOE6NiPFeSk2zoLmqxBoLZDrpjFLJLZm5G+Ma5XlTvnsl4hKJ23z891/XLly48NFHH3V1dRmG0dzcnJOTU1ZWpqrqkDcriuLZs2enTp3q8/kSiYTdId3udYMDKJSWeDwuSVJLSwuI49QibXf2QyrjkIoDB7Q3wlUZhgHVEEqsqqqJhJU1xzq1IAipV2VvsRsBKNJwVU6nE04NnTqcAhoWuFr4bEsQqOZwcE3TLl269Pzzz8PTgIYIGh+3293U1KQoCigGuGs4EVQHuBhZlqEO2r7yw9uWW5LankBtgp1B02iaBi/Rrl+222HqmCd1fzJSMJMPm4/6RnYlcJ8hxJm4QpRGwnuJHmOE44QMRnTLNU0myetmTZPGETGNagNED5nbWYKZH0TGuSgnO5QGovYQpZOI6U61hwgOwtLNJKuyQIhhhY6/n7YI7CB79uzZu3cvY+zMmTMOh+OFF16IxWKXLl0SBAFsUresC6nt5PBmFn4C75fjOIfDkdp/wVf2ywUDc2rBgJZc1/XU/hH2UVUVzgutMfhSulyuuro6TdOqq6sTicSQSup0Ou2+786lUVEUnue7urra29ttAQ0XLEmSKIqqqtbV1U2cOBEuzC7DUGdPnTo1d+5ct9udTCahkUntQezuz35W9sIwuEGHw2FXN7tew6R3MBhcsWJFe3v7xYsX161bB6ew6wVjTJbl1tbW9vb25cuX9/b2Xrx4cdWqVR6PJ3W34ZeE3Cso3O+E2Q5ZY/X54zxHW7W2MMfxQiSp7zzelp/hGFucFkroaQ5O5GhUYZrZBNK4YsaIdAlGbVviXFM0mmSCkxqcOLlAHpMtQIamB70qaxidmZm5cuXK8vLyRCLhtICaBlXCXuUDvaymaYqiFBcX/8Vf/EVmZqbdo6cOuIebA0GGgnHOPhq0mLAFNoIuMQwDzjVE/duS+pZHgN3gLHBG26oB34IdorOzc/ny5WvWrLl48SLs/NJLL8Us4DLsNtqerLRPDbKjpqbG5XLNnTsXWgq4ZvtBDXnC9j7251dffRVuDR4vfAUt3dq1a4PBIMxdwENIDTiTeq5bHjn1pPAAUx8O3MXwn4N+GjkmwBQYoSLPOM4Imc4wxGF5upshVK0vVUJiprP7zdzrN2OwmwHuqBlexly0ajgj9RF9gcGZ3RUhZvQYQlhSN9e1UkIcgvn03BKReOIVOY/p63vPw2V4BbFY7N13383MzPzud7+radqWLVs++OCDv/7rv04mk9BlgpEMCuHhw4eLioqKi4vj8bhte4Y3ONyUC1vsr+xClfqr1IqTWhKGVJzULanHtM8lCEI8Hp8zZ86MGTPgJ7DYOtV2DkcbUiPso6VWTFvaQo2wK7V95anV3B6+2tttBQwbh/zWvqNUa1xqDbU/2y3bLavw8Lm+IW2dLc1TmwL7+KnzcvZ5b3eiryBWbHb+Zij3G7WI8ZRKBYxzUNHPzBjHOqOCFchJoLxo1SSBCmnWQlOR8LmEl8yJZD3TispkUN59c21KIfWWMjqTOtJNcS+l3ayidhKnewCsLefOndu/f//GjRunTZt28uTJ3bt3T5s2DSZIb9kNpdaF1G7odg3vLXu0G8/q99/pEPt66vYhn1OLum14unLlSiKRmDdvXiKRgJ1TS+mQGxlSGodcsz1CTn1WsI+qqnDe1EuFakUp3b9//8SJE7OysuAa7A56eEuSekfDHwgojfXr18MpGhoaWlpa1q5da1feIT45MApqbW09ceLEmjVrUuM3wKUOr3T3WloQAIX7F0CtvNDl2fKsCm9bs8TpKnH7u6Pq9sPN86eTNL/bYEQWqSxwiZhp09AYM1S9pT9+6UpfV4wX3T5dVX18cnFVtkcyl+Q/lJYfTGgVFRXjx48HlQBVa/fu3RcuXBg3btzKlSt5no9Go1u3bm1ubl6+fHl1dTWMgBcvXkwpdTqd165dq62tXbRokcPh6OjoOHv27IoVK0B9CoKgKMq2bdsaGhpmzZq1YMGCZDIZj8e3bt3a29u7ZMmSiRMnGobx2WefZWVlnT592uv1rl+//oMPPmhsbFyzZs3EiRPPnj0bDAY5jjty5Mjy5cunTp0KlsXf/va3AwMD8+fPnz17NlhZ8vPzjx07tnTp0okTJ27btu369evz58+fPn26bebfv3//mTNnMjMz9+zZU1BQAK1Aa2trLBabNm2aoiifffbZ+fPnly5dOjg4OGXKFFEUHQ7Hnj17Ll26NG/evNmzZx+zEARBkqSvf/3rp0+f3r17t9frff7557OyshRFGdJ2OxyOI0eOHDt2rKCgYPXq1X6//9y5c7Ci4NixYx6P5/Tp0+vXr4dhUmdnZ0dHx6JFiz7++OOcnJwzZ86Ams/KynI4HA0NDbt37/Z4PGvWrPH5fLqunzx58uDBg2PGjFm9erXtGQ+Gjc2bNzc3N8+ePXvevHmhUOjChQsOh+P06dNZWVnPPPOMx+MhhBw7duz48ePQq40UGfE7wCTHUeq0IrKrpru7FS8aXGis2pG0Pjgsf3foOsEGL5tGembOGAlyqEZUexNSiWboqkGcAotrEOLJlO/m0EAw58o8InWJRL6vpXJQxerq6gKBwCuvvAIFPhQKffDBB11dXTk5OY2Njbt373Y4HM8//7zT6dy1a9eVK1e2bNkSi8VmzpwJflOiKB46dOjEiRNjx45dunQpjK6htoqiePXq1b1797rd7rVr10KphoGfrusHDhy4ePHi0qVLp06dChXho48+unbt2pQpU5YtW6YoSmrFGT9+PJjSd+7cOWbMmAMHDjgcjtWrV+fn5586dSoWi7W1tRmGsXTp0qampqeeekoQhHPnzh06dKi8vHz58uUul8swjAsXLhw4cGDs2LErVqxIjaIDlu9t27ZduXIFrqejo+PatWuapl27du2ll17iOA5mJNauXVtSUkIIiUQimzdv7unpmT9//ty5c8HoCOPnHTt2OByO5cuXnzp1avfu3QsWLAAbPPTre/furampmTVr1vz586FFWrVqFcdxO3bsGD9+fFVV1alTp0B/KIoyODhYX1//zDPPTJgw4ZbeYhzHbd++vampacGCBTNnzoTHMnPmTI7j4LEsWrSotbV1x44dGRkZK1euTE9Pb2pqun79OmOsr68P1g5NmzaNEFJTUxMMBpcuXZo6l/IVxlyTyqiDUo5AHjJKCW9pdNFDBadlKWfUsBSkmTGBswKwF1r7EGJoRPCZBntmhY2R/FYeNNWsUaFBxglcUTXxFpljbsFhDQ/MdSQPcrng+FdaWrp8+XKfz+fxeE6dOnXlypUxY8Y4nc6zZ88eOnRo+vTpTz/9NNSFLVu2NDY2wpZIJHLixInMzMwTJ05AVfL5fIZhnD59+vPPP582bZokSX6/f9q0aeFweNu2bS0tLQsXLpw2bRpUGZfLdfz48VgsNn/+fFmWa2pquru7ly9f3tPTs23bNkLIihUrKisrGxsbz58/D6Xx8uXLfX19q1ev3rFjR2Zm5qFDh6qrq+fPn28YxpkzZ/bt26coit/vX7JkyWeffZafn3/06NE1a9aUlJT85je/6ejomDVr1uLFi/fv3+/1eqdNm8Zx3PHjx1VVXbhwYVNTE3QiK1as8Pl8qR44tr4/fPjwqVOn5s+f73a7YajQ0NCwfft2juOWLVs2bty4d955p6Wl5ec///nXvva1adOmnT9/fu/evXl5eWvWrAHb/MmTJw8cOJCfn//888+7XC5VVUVR7OjoqKmpWblyJWNs+/btkyZNGjNmzIkTJ6D6gwvQvn37QqHQm2++OW7cOL/fX19f/84771RWVi5btgzaLlmWoU1ramp68803Z82a5XQ629ratm3blpOTs27dOpgtqa2t3bdvX3Z29urVqx0Ox/DVL8gXgsL9i2EGkQR+XvbAGWeoyfDJkoNQcv5Kd5TJxXm+4kyxIMfnlrlonIRjbCCYDESMtq5gR8eA6M+gksNIKjMKuCmFVjKYh3hVlrCwZ99UVT137tzHH3+sqmpzc3NxcfHMmTMPHTp0/PjxRCLx/vvvFxUVJRKJbdu2VVdXwxFCodCePXuqq6szMjKuX79+6tSpFStW2LaE06dP7927V1XV7u7unJycsWPH7tq16/Dhw4yxaDSak5OTlZV14sQJOE4oFBJF8fLly/X19bIsjx07tqur65NPPikpKamrq0skEjk5OcXFxR988MHhw4dh/Wh5ebnH4zl48KDL5err61uwYMGlS5d2796tadrg4GB+fn5ubi6onL6+vmg0qijK1atXCwsLYbx+8uTJSCSycOHCI0eO7Ny5MxaLEUK6urry8/MlSers7IxEIteuXQsEAhMmTAgEAiCkurq6otHovn37GhoaFEVxOp2bNm0abjO4du3ahx9+GIlE6urqcnNzV65c+fnnn1dWVi5cuPD9998vLi4Gxwm4kvPnz1++fHnNmjWff/45z/PxeLylpSU3N/e5556LRqO7du26fPmyYRher/e5557r6uravXt3d3d3S0uL1+t95plnwCgiSdKePXv27dunqmpfX19FRYUoinv37nU4HF1dXcePH6+oqJg3b159ff2OHTsGBv7/7P13cFxXduCPv9Q550ZGI2eABBhAEgRzEJMoUnmUJXuCvbtVXv/xW9u1tfv1VHnGXletp1z2jDQzkkZpRoESSTGCOYJEBpFzaoQG0Dm/8KvuI1/3AhRFRQrQ/dSMCux+/d59791z77nnnjDv9XojkUh2djaxFBEEQhyLOiXANwZ0bi6msscM8KLY5zwXj0+Nx9dBLUeBjJeEiRWPoWnPpMzRHEpOi/CxVHRQCVIu+qzuepiLpa4OszEroFL8FVOvwjw0NDRksVjKysp8Pp9IJFq9erXX6+V5PhQKnTp1qrOzMxqN6vX67du3z8zMQNj3/Pw8msY6OjqOHTvm9XpHR0fNZvPatWthX4imaZfLdeLECQjeEolEL7/8MhjvGYZpb28/d+6cy+UKBoNmszklJeXSpUtnz57lOG5iYsJms6WlpSHBWbNmDbJjXb16tbOzc2pqyuPxyGSy5557bmRk5MKFCwRB5ObmDg8P19XVrVy5cnx8/OTJk5OTkyMjIyqVauvWrXa7/fjx45OTk9B1V6xYgRxnaZru6uoaHh622+1+vz8zMzMQCJw5cwac1DmOq6+vv379OsTJPf300wqFoq6u7urVq4IgeDyerKws8CWQyWQjIyNnzpzZv3+/w+E4fvz44OAgSZKTk5PJyckkSXZ0dNTV1Xm93rm5OYPBoFKpzp07t2nTJoZhzp49S9P0ihUrmpubVSoVwzDXr1+3Wq3gU5Gbm7s47FUsFsMIxrKs0+nMyckZGRlxuVxVVVUURd24cUOj0VRXV584caKtrQ0ijw8fPuxwOE6dOiUSicxms8fjCYfDMFo2NDSQJLl9+/YlZHSPeb/EBeYzKzhNx8JBYmlWaYLkY1mL48VG4o5o8fTujDj2Py5CxlJJUgRFCZEIEY3EHmc4JAQCgt/L+31kygpClUWIFPG8x/FyxzG+1jMRBGFkZKS2tlaj0czOzqrV6j179oBb1Nzc3M2bN7u7uycnJ3Nycmw225kzZ86dO8fz/OTkZHZ2tkqlunr1qlwun5mZmZ6eBq/Rvr6+48ePT09PRyKRycnJ3bt3r1279sqVK+fPn+c4zuVyJScn6/X6cDgsFovHx8d7enrWrFkjlUpbWlo8Hk9tbe3Zs2ebmprAhzslJcXpdF65cmXXrl00TQ8NDfX29j766KM3btzgOG5kZCQ3Nxd2Blwul8/nY1nWbrdHo9ELFy5oNBqHw7F9+/ZLly5duHCBoqjp6emioqLBwcFwOLxy5UqKoq5duwYxHidOnLhz5w7qjQv2zUQiUVdX16effupyuXiet9vtEonE6/V+8skn7e3tMOakpaVNT09TFDUxMeH3+71e7/Hjx0dHR7u7u41GY21t7ezs7MWLF0dHRwcGBrRa7c6dO2E9EAqFzp8/v3nzZo7jzpw5I5PJysrKGhoarFar1+vlOK66utrr9bIsOzo6WlhY6HK5bt++PTAw0Nvbm5aWVlZW5vf7KYryer1ut5vjuNHR0crKynA4fP369bGxsebmZpvNVllZ6XK5Tp48OTQ01NHRodfrN23a9HX7+Q+SJbjV/p0TL7tO2YLNtdI2rULgWJYLBUiSGBp332wevtJsv9Ltu3jH2Tni6ht19/bP3BkLTM+HiFjoD8lFwulm2dZijUoSr7f6zY35PM/Pz8/DaOXxeGiabm5uVqvVP/3pT9Vq9eXLl2mavnDhQkFBwV/+5V/Ozs4ODw+D2x8IajQaTUtL8/l8TqdTLBaPjY1ZrVbwyYP8MydPnrRYLC+88ILX671+/XokEjl9+nRpaemTTz45MDDQ3NwMpxodHT18+HBKSsrbb7+9cuXKQ4cONTc3OxwOtVrd19en0Whefvnl8fHxxsZGiqJu3ry5du3aF154YXJysrOzUyQSsSw7Pj5+6NChtLS0o0ePwhUdDkdDQwPyQ6isrMzJyVm5cuWuXbuQPwwoKwzD1NXVURT153/+5zBGwwbi4OBgamrqk08+OTg42NXVVVVVlZubW1RUdPDgwa6urp6enpdeemn79u1tbW0LAvNBcb9z504kEvmzP/uz3NzcixcvQsYDCBiamJgQBOGll15C4QEwZMND6+vr279/f2Vl5a1bt0QiUU9PT2tr6yOPPLJq1aqzZ8/6/f6enp6ZmZn/+l//K9gzEi9969at3NzcH//4x06nE2zt09PTfr//6aef1ul0ra2tEomkvr7e5XK9+OKLOp2uu7v7u09l83WJl0yK+93GTHWQyp1U/od9Pb7fTiriyd35mPoeq83kj/nPCGFB8AixnO7heAmZMKGcuiKJ2AWCkFCxcsUimpQysd+L45VnKEJQSihZLMfFVxc5kiSdTqdWqwV1LRqNhsPh2tpai8XS19fX0tLy8MMPr1+//vTp07CGNBqNmzdvhl0g6C0dHR0EQfzsZz8zGo03btxAm+MMw9y5c6ejo+Pw4cNr1qwBhRUEMxKJXLp0SafTvfLKK5OTk7dv3xaLxbdv305OTv7JT34CJjeJRBKNRicmJg4fPpyWloa2jARBaG9vh/5WV1fndrslEklnZ2d5efn+/fvBm4um6Zs3b05PT7/44ospKSmXL1+GNf/09PRLL71kNBrPnDmT6OvFMExbW1tubu5TTz3V09PT0dEhlUrHxsbEYvHjjz/Ocdz58+dLS0ufeuqppqamwcFBjuMaGhoqKytBzKEng5n89OnTsFitr68fGhp68cUXLRZLd3e3XC6PRCIXLlyQSCSvvPJKOByuq6szmUygCblcLr/fPzU1RdP0zMyMwWCQSqV9fX1lZWV79+7t6+ubnZ1dLAg8z586dSo5Ofm5556bnJxsaWnJzMycnp6GncOpqamsrKyxsbHbt28/9thjK1euPHfunNfrhRwaOp1u3759ubm5Y2Nj4Atkt9szMzOXVmpCkk6M/o5DUQn+M2RcO6dj6d7jFZriVVIJghHF/o4VROWIaJjwuPiZKd4+xg/38tMThNRMpa+O2exj+vp/hL1+Pa0dJCsYDGq12lAoJBKJwuFwZWVlVVUVSZJTU1MkSb7wwgsul6uhoUEul1+/fj07O/snP/lJOBxubGxkGMbv98/Ozj711FPJycmgwjY0NExNTb344otms/nOnTsymSwcDp85cyYtLe3ZZ58dHx+/ffs2RCtFo9H09HSv1xsIBDiOgxc9OTl58eLFHTt2PPTQQ7dv3+7p6ZHJZAvSl0Gze3t7Dx06VFZWFg6HQ6FQUVFRWVlZcXHxzp07aZoOh8PT09OPP/54UlLS5cuXS0tL//zP/9ztdt+5cyczM3Nqaioajfr9fofDkZ2dPTw83NTU9MQTT5SWltbV1YEevCAI6tq1a8Fg8OWXX6Zpuq+vT6FQzM7Otre3Hzp0aN++fW1tbXa7fdeuXUql8sCBA4WFhY2Njf39/U8//XRBQcGnn35K03RHR4fdbv/Lv/zLysrK5uZmcLnhed5oNAqC4Ha7E8XN4XCYTCZw18nKyiorK0tPT9+7dy/Y0aPR6AsvvCAIQn19PYr2ycjIWLFiBZjzlUqlz+ebnp5+9tlntVrthQsXFApFa2trX1/fU089VVhYeObMmWAwiMs4fAWwxf2+EEhCNNVRI7TPyVTn/FUsG6EYhheEgDcwxgpznIsIemmGZgkq7HHz+jRB4BmVTiBJJRXZu9JckK6I7zp+Q42JG3q9Xu+//uu/ymQyj8dTXV398ssvl5WVbdiwYeXKlRMTE2AD83q9VVVVK1eufPbZZ5OSkhLDz1mWNZvNSqXSbreXlZVNTk7m5eWBh4xEInE4HOAhUFJSYrfbfT5fV1eXSCTatWtXcnJyW1tbV1fXnj17IApnw4YNo6OjY2NjkHDj/PnzPp+P53mz2VxTU5ObmwuW+GAwuG/fvuLi4tTU1GvXrjkcDnB027p167p16+bn56empn7yk5+Ul5ePjY3BhjXcrMVi0Wg0ZrM5IyPjzp076DmQJBkOh0dHR3fu3FleXk5RVF9fHzjzaTSaLVu2WCyWM2fOjI6Owj64TCbLycnp7OxUKpUVFRUZGRlmsxk57KJzsiyblZWVnp5eVVUlCMKbb74JXvuws6FSqbZt27ZixYrJycnFXsuVlZVr166lafr1119nWbarqysvL2/r1q3z8/N37tyZmppyOBxgeIAUk7APADeyefPm9PT0srKy+vp6WB6QJFldXb1hw4bBwcG+vj6fzzc4OAjOP2q1ur6+folp7Z8hEJQ0FotKhWH9FZv4RTQl5fkoHxuQqFjx1FhqyHjW9rjWHtfjwa8G3GxFlDg6rPFcCGgPCXQsDjLExRWPeP47QSAZijQrqCR5zCvnqz0jcF7y+Xw6nQ6UA7Ci0TSdnZ3d2dlZUlKydevWQCDQ0tIyMTGRn58vk8nS0tLA+Qqm7YKCgsLCwvXr17vd7pMnTwaDQbDhwQxaVla2bt263NzcmZkZsNNDaLXb7X766aerq6sHBwcHBgZCodC6dessFktxcXFPT8/g4CDMtVu3bl2zZg1YvlG+iFWrVlVVVWVkZDQ1NUFcqc1m27lzZ1paWm9vL0VRgUCgt7d3w4YNa9asEYvF58+fd7vd/f3927dv37hxo0wm++1vf+t2uyGeDPq8xWIBaWpsbOzp6UlJSRGJRDt27FizZs2NGzekUunevXszMzObmpp6e3uLi4t3795dWFiYnJx88+ZN0ADAMa+lpeW5556jKKq7u7uysnL9+vVpaWlXr17led7tds/MzDz88MNVVVXT09MXLlwIBoNGo9HpdEIswczMTCgUcrvdycnJXV1dhYWF69atczqdTU1NDocjPT09cfVC0/Ts7Ozc3Nx/+S//BaybXV1d27dvZ1nW7/eD1CQlJcFLfOihhyYmJnp6esbHxyGs9tChQ+np6QzDhEKh+fl5hULh8XjS09OXzp4+qObimHf7Z6nY4xvHcdf3mJr+WRApxK3ysXROsYyp8RSQhECGw4Tfx0dDgtstuGdhQ4uIRgmFgcqrJZXGr5ih6W7Ay/L5fIIgaDQaFGYNo2I0GjUYDLW1tSUlJVeuXJmamuI4buPGjRkZGSUlJS0tLbOzszB4bt++fd26dYODgz09PV6vd3h4uLq6et26dUaj8ezZs6CSzs7OPvfcc4WFhb29vX19fSiYNTk5ORAIwHTpdrszMzP7+/stFsv27dt5nq+vr+/t7V25cuXiNAY8z69YsWLr1q2oSIJerzeZTKFQKCMjw+VyURQFTqrgqJadnZ2Xl1dfXz85OQnW6EAgAFOAxWJpamoqKyvbtWvX8PBwf3+/3W4Xif5zlx6e0tjY2ObNm9etW0fT9JUrV6LRqEwme/LJJzds2BCNRuvr6+fm5qqqqiQSSVZWll6vb29vX79+fW1tbWZm5s9//vP5+XnwASsvL1cqlSjVpiAIUqlUrVa7XC4Yu6anp0OhkNfrTUpKGh4ehmQyMLKB45BCoVi3bt2aNWvgLUB8OcuyGo3GYrGMjo5mZWU5nU6GYWpqaqqqqvr6+mCV1d7eXllZCS/xn/7pn+bn51NTU9EIhrlPsMX9fl0G2WjYGHFso+pXSzsImZIlJYyIFkklPMl43R5vWJhzev1hIUqK6GiQEvgIT6kZfne5rjpbKRHR3DdaYwSMcwqFQhtHoVBwHFdZWanT6RoaGvr6+oLBoEQikUqlFy5cAOmFVBiJOaFkMllycvLs7KzH4/F6vSkpKaj+xczMjEKhKCwsZBimOs7o6GhycnJ6erpcLi8pKZmZmQFzeF5enlqt1ul0NptNr9frdDq5XA6B86mpqVlZWQqFori42Ov1hsPhTZs2BQKBhoYGl8vldrvBUF1SUqLRaFwuVzgcdjgcTU1NExMTAwMD6GYhWQ14qCc+BPA3YFm2rKxMJBIVFhZC2ime55OSkmAzFCIFEytVwfB0/PhxgiBqa2shgj7xwUYikeLi4szMTPCB8fl8KF6NZVmDwZCfny+VSu86A+Xn5ysUCpvNxjCM0+l0uVyhUKi1tXVoaCgYDM7MzGi12t7e3jNnzlit1pqaGsh1AGeorq6mabq+vh62JiORiFqtzsrKUqlUNpstHA57PB6Xy1VcXCyVSrOyspbkeBfTGDhCkkTIMmPZo2NKOxVzc6HjXjGiuEEQdu8lMbt7zCQvj9nj4b8xN/f4/n9M7RdHlb5LhnC9iIpNPixPRGMhqrH6qjDXGWWEUvLV66Wi5IPQbfx+/6effvrmm29+8MEHkNp8Zmamvb19aGgoHA5PTk5CAhMmDpyBZdni4uK0tLTbt2/b7XbQEpByabfbi4uLlUplUlLSnj17IEM8xKWMx2lsbAwEAjMzM4FAoLq6WiqVwt40aKggOEqlMjGEjiTJsrIyuVyemZlpNpsdDgfP8zabLTU1FVrFMIzP5wuHwyUlJeDStnXrVoZhhoeHHQ5HY2Ojw+Hwer2zs7Og1oDinp2dnZycrFQqi4qKZmdnWZY1Go1ZWVlKpXJ+ft5utw8MDLS1tcEmAE3T69evDwaDt2/fHhsbg1VKOBw+cuRITk7O6tWrQS6KiopUKlVGRkZ6ejoED3AcV1hYKBaLi4qKwKfWYrF4PB6Hw5GRkREKhaanp2OvNa49wA1arVaFQrGgmgFI4tzcHLj5NTU12e32np4eq9UKp3W73QRBgC02EomAeMKeJMMwWq02NzeXpmmj0ahUKmEBQNO0xWKBfQNiiSDEhGSRYS623xUPKInXXPqMmMWdJjhO8LoE+zg30seNDfATY4JzTggEiKCfiAQJhZ7M20iZc+Dc33BT/18HJJIkg8FgJBJhWVan0+Xk5MjlchgDBUGorq6WSCS3bt2am5uDV0nTdE5OjlKphF0R8FcpKSmRSqUZGRk2m41lWbfbHQwGJyYmQKwcDkcgEIAoT7PZLJFIZmdnYfFsNBonJyczMzOtVqvBYMjLy5uenoZkAAvaTFFUUVGRTqdDX4H4o9LdIpEI5JEkyQ0bNsC2qtPpdDgcycnJHMfBjjdN0waDAfzuWltbR0ZGHA7HyMgIZJ75j1cUM9XBkCKVSnNycpKSkkKhkMFgWLdu3ejoaHt7u9fr9fl8YPyG+KuRkZG5ubnm5mYwEtntdoPBMD4+fuLECbVavX79eiQ4DMMYDAaPxzM7O5uZmRkMBsHlRq/Xo4hYuDWxWMxxnFarzc7OViqVubm5kThIeUCHgQtoUVERxOMJghAKhZxOZyAQgCbBbsMSkqnvD9ji/oXEilcQYSeljbBKsS0ysYu6HDGau/0Wl8fPx0J1GJoiaYmUE6KUVMaLJVFeoDg2VcuvtikeqjRqZCQbqy79jTUIZlOZTHbgwIGcnJxAICCXywmCmJycPHXqlN/vv379enJyslwuLysrO3HiRDgcXrt27ebNmxeUS+A4Li0tbS4OQRAmkwmpsB6PR6FQwCpfpVLl5OTcvn1bqVSGQqFoNCqXy1F2J3CPg9xYoVAI3F5BpwftNhAIoBSQra2t4HnS3t5utVqRxIbDYfBiv3LlilwuB09WZOGA3BQoEd6CpB8QcAM+7jBYCIKgUCgCgYBYLEYxAOCSHggEMjIyTCbTp59+CplqUlNTF8zHNE07nc6TJ0/Ozc21t7cHg0EUvA+eAxzHBYPBu74aMM3SNC0Wi91uN/hu1tXVcRwHT6ygoIBl2Q8++GBwcHDLli1GoxFuimGYnp6eixcvwvbrunXr4BVDm5ErDvgKw7OCVQqxFP3OxCZCv5ngQkRwiIAaqBFKiIJdMH7Uf6oUcX2diw9UDEHGHeIhVlWgaDoyrg3Xc9p1Po4RcxxBxtR+niA1EkItJpWfZQ78ioB/FORjQflGeJ7v6uryeDyRSKS5uRlmNdiQgcQRKNMcqI8Oh+PMmTMul2tsbAxStqGTh8NhhULh9/vD4XBxcbFWq4VkLzzPT0xMXLhwobe3d2xsDDb0h4eHT548GQqFbty4UVlZ+dmjjIvegl0XuVwOdn2FQgEtF4lEKMsNmCdhDQzO+itWrAgGg3Nzczdu3AgEAh6PB2VbhxMKggA+DBzHKRQKUKfAuSUUCrEsOzAwcO7cOY1GMz4+XlBQIAjCnTt3Ll++DEvWlStXMgzj8Xjq6+v/+q//WiQSQZtBZsHUByMAZJ/weDyQ/T0Sieh0urm5uXA4nJ2dDcUZVCoVBPjSNB2JRECdgpXMghQZ8GAvX74slUqbmppMJpNarZbJZA6HAwYrnU43MTHh8/lOnToVCoVcLhecQSKRwHMTi8VGoxEWTmAcWUobXLEaTPGlcGK+FzTKkeAYQxJslAiF+ag/5hXjcwt+N+90E0EvwYhjwhSriSYX2DAhEpMpFVT6qtiiGSz33xAgUzBKo8BfGMDB3gxjbygUAn2RYZi+vr7Lly9HIpGGhoa8vDyUBRUGXvC0AUc10HSVSiXHcYFAIBKJXL58WSaTTUxMaDSaUCgEg7lMJrNarQ6HA/JFgoOHSqWCeU2tVtvt9sSg5MTJAgZ8lEwMxH9BieJQKETTdGdn56VLl8AtrayszGAwwM62y+UCazc4n4jF4kAgAHPHgskOMlmBNBEEoVQqwUp1+fLljo6OYDDY39+P5l9Ip+bz+YaGhkBGIP6qoKBAKpV+/PHH4+PjsI0GMyPDMGq1enZ21uv15ubmInGD8QdtKaAEsvB20HtJHNlQA1BALaRgpijK5/MRBNHX1wc5o++aJBdzP2DF/YuIV50jPHcY+QiVQXODVA438XxK93FZ2Y3Wca8zSFKkIFVw4QApklF8LCEjI1eoWX5PuWpzqUkqjg+h3/SSEiTNYDCYzWaYlWmahiCVmpqa7OxsmFZ37NihVqsvXLjwm9/8JjU1VSaToRxM4BOSnp7e09Njt9ulUqlOp1uQnAEVRQJTR2JZODRTotyLiTUp7ppkKhAIvPnmmwRBQIpZtNaHM4D2nJKSIhaLIV4WtAck/ImnQg0A6wIs90E5TsyimJgJDoDdzGefffb8+fMXLlxwOp0/+clPIEs0qoUhl8uPHDly4cKF9evX5+Tk9PT0LL6pz6sckfg0wMJqNpvBNA7JDVJSUn7605+eP3/+yJEjoVDopZdegiE1Eom8//77Dodj27Ztk5OTSHOCEyaWw0AszfEONvEZQr+RYLSE/W0iMkGQsQ16IRrXd1mCYAXkiAu5IIVo/F9czFvms3Pw8SN5guHDRmlUxMlkNBc7S/ztWJSkSkRSFFJZvgqgeYOqF4lEtFrtn/3Zn3m93p///OcQ3pCUlJSamgr1EKxWK+okifkKITX1zp07BUEAb110cnQMWpLBtyzLqlSqtLQ0s9kMfYaiqPfff39kZAT2zRb89i6P+D8kBe2DL0itiIoqgLYEWaVTU1NTUlLAJ02lUi3w515wLdBUkEClp6dD5r68vDyv1/v222/TNF1RUZGcnIwW2zqdrq2tbfv27TDlQyMXVLRB2SHhAIPBcOfOHYZhIG9Md3e3Xq8Hj3nIlIeEffETgDOAV8+aNWv0ej3DMKmpqeA+lJqaCsYOpVKZlpbm9/vFYnFWVpbP50PpfcRisdlsttvtKpUqKSlpQaLb7z0CSTHx+FSkrMPCOO5qxoPjpkAEg8LcDD/nEAJeIuiP1V2K1RkWkWJ5zG0m4icZKcmISWMOlb2OZCQJy4BvrqHxYVwqlUIWMnhxsBWJOkliP3nvvfdmZ2e3bNmiVqshtgFeWeI0BIl6YYpBs4NYLM7IyKBpWhUnsbRZZmYmbE8plUqNRgPCuDiXKDLfJDY+MSXi4qkKThKJRN5++22fz1dbWwvVYWUyWWpq6sjIiM/nQ71RpVKlpqb6/X6JRJKRkdHZ2blgtYAyJsOdQnDaG2+8ATt7EokELP1ogqAoKiUlBfJSKBQKlUpltVpffPHFc+fOHT9+PBgMPv/88zDFMwyj1+vHxsZ4ni8tLQ2FQt3d3bC6QDWh7npri5NpJkolen3oMJZlrVYrVJWSyWRarXZpbWR9T8CK+72Jj1NcRPC2kPw8pZfyPl4S0KblZu8z6YvNdNeou3c6OulmZ0MRsUxhEIXTUlRFmapMlSzHKtEqmDAb0ye+jV4JdimI74S9xeHh4W3btm3evFmtVoPnqNVq3bhxY1pa2ptvvnnnzp1Vq1YtcOZOTU0NBoPd3d2aOCj1rE6nC4VCkUgELHP9/f0KhWJsbAyC2yBz/L0jI8HnBOwZoJvOzMyEw+HnnnsuNzcXCiQlLtPlcrlMJtu0aRPc1/0ErKAqbhMTExUVFS0tLcitZTEo2S3DMEVFRUql0mQynTt3bnZ2Njc3NxwOo0ULx3E9PT2rVq3au3fvwMDA6OjoVxhZIOePSCSCbFnhcBjcZ8VicWVlpVarhehSt9sNBZXA/f3AgQObNm2anp4Gp6YF54SaNWBPjUaj4EO5VNV3RkGoywhaSni7CH8vyQ0S/olYYVSeFtwMoYq7xCA9XxIztPPR/6jHBPv8PEH4KEJGiChSIyKUopgDAB8riEbIxTHvG/7L527/f5oYFxCr1dra2oomNvhKqVTKZLI1a9Zs3rwZ3qxMJgMxRH4yICZ9fX0bN258+OGHb926dezYscQJVaVSwasUBGFgYABpJzRNZ2ZmQj446K7Qwx966CFIrdjf33+PZoNZTiQS+f1+uVwOJi50R6AkgfUO+tLw8LBer4fSy2VlZdDxwJiH1F+PxwNG+mAwmJiEFOyaRUVF27Ztg38qFIrx8fFAIPDMM8/k5uaClsxxnFwuf+WVVyBD66pVq0CVgd0MCLyRSqWgGcMqGvL0JSUlnT592honEAjU19fn5ubCxsVieQSFHpoNRly5XL5lyxbYOYFVdGZmZmdnJ8MwOTk5oL5DolUI0IcQcKSiURSVmpra2Ng4OztbWFiIdEpiqUBSBKMVwtOxUG1YAVM0wcRdYtxOYWZKiPgFv5+IRoRgQIiEYwo6LRG4MCmSxpJI0jQp1cT2xzRJVO5GUmmIffjtAGPj0NDQzp07/X6/Uqk8cuSITqeDHGJoiGMYZnZ21uFwHDp0aO3ateASs+ClQA8XBMHhcEDO1qGhIcjEqlQqa2trUcEjpFlyHJeenn7y5EmoECyXy2HXBYZZn8+nUCjA8ByJRJBr5T0mmgXtYRhmbGzM7XY//vjjK1asgOGdZdmMjAwQ/MLCQp7noQTEtm3b3G43wzAmk6m1tTUxHSTcF1jlYdeXpune3l6TyfTEE0+IRKLE42E5AXkwN27cCFMwFOwrLy+HCQhmTNjrI0kSglLAAw1CgQsLC9Eye/Eq5fNIrMey4HO5XA7z74YNG2DABGPiV+o1P2iwj/sXQYmI0BjhbSZ4iiCjdLKOLz8QTV6Vqac3FRt2r07dt8q8b4XmwGrLvirDvpX63WXqbXmS9flag1riD7MC/61o7QCY1WFHj+d5r9dbVFSUn58/Pz8Pc/PHH38cCoV2796dnp4Oe9DIXg7Tm06nk0gkDQ0NycnJKE0Kz/Mmk8nlcnV1dclksuvXr9fX19tstqGhISjk1tLSotPpwM6RuLD+7IHFZzhIYT48PAzHq1QqGDHXrl0LqwKYTVGhFpPJBNudhYWFfr+/q6srsZBy4pI9MZwU3PRPnjx58eLFY8eOISd+1Bj0N8MwsCnZ2dl54sSJgoKCbdu2gSu50+mEEDq0F+FyuSCI3ufzoXMiE3hiqxIvkfg0QKcxGAyQTDMpKam9vT0cDt++fbu+vn79+vXV1dWQxwA2BwKBAM/za9asQQF5C04IXoNKpbK1tZWm6cHBQbvdvqDW9FKCCxO0hNCuJkw7CdMeInkvmbabSN5C6LNjJnZ/PJ9M6D80dchrBxo8VIFk49+GYqF08YJOsdLFMhGpEJNqyWcFjL8mUM0xPz/f6XRev34dghaOHDkCTmXgD2qxWJKTk7u7u71eLyxEnU4n6hUw65eUlOTl5YH7bOLJLRZLc3Mzx3Fzc3MnTpyAaZjnebVaDRVDCwoKPB7P4OAgQRB+v7+8vNxms83NzS3uh4nU19cTBDE6OjoxMWG1WhPrOoEiDtvfzc3NDMMMDQ2dO3cObNsulwvSZnd0dKDYCVA7ent7IQNGe3u7wWBAe1kcxxmNRsgDnZeXNzExMTU1BTvgq1atMhqNc3Nz4PwjkUi2bdtms9nOnTsHm3stLS08z4+Ojvb398PGQiQS6ezsFIvFd+7cgeeg1Woh7anJZFIoFF1dXTqdDp7zAgGHUyGPII7jzGYzy7LgG+DxeGDfLDMzExoJqXhsNpvb7TaZTBDwCr7yaJzheT4lJcXhcAwPD6elpS3JFbLIENvXiuVZZ2M52kNhbmKIG+3nRvr4iRF+bDhmaw+GYjndxVJSoSZlKkqiimVn/8ydhiakKipzNWnMiudn/RYVrPz8/MbGxqGhIaVSOTEx8cknn7jdbtCw4QAYJ+EVr1q1CiJKUQ2vxIpIMpksPT29Ls7p06fBB0av18N0WVRUNDc319fXB3owRC6lpaVNTk4ODg5CIQKr1drT0zM/Px8MBjs6OiCj//z8/PT0NDjLIRlcrMXCRJM4L4BZjabpNWvWmM1m8OGMRCJZWVmjo6Ozs7OpqanRaNRms7lcLovFYrVaOzs73W53Ym+EjTgI7qRpur+/f2JiQiKReDwek8m0Zs0aWGbAjABBIyKRCObxtLQ0CFSlKOrWrVuXLl2C8NBgMIjMVWjSh7kYxE2v14P3KcxoEonE5XKh2k/ovSwYi8BqABsdiYfBGbRaLQig0WhsbW29q4kK84Us2Yn/u8RzmwwME7Sc4IKkqYy2HSAIJhiJLbtTtHSGXkOQGoGIG9LiW5GsIAQiLEnEUlt8Sy0Cv7H29nYI9dBqtRAEc+nSJY7jbt68CXUNTp48OT8/73a7R0dHoZIZ7PaiioYikchisbS2tkLOBGSB0Gg0BoPhzJkzUNRp5cqVkDK8rq6uuLi4ra1t7969qMYyiD3aE49Go+CMODs7e+PGDZfL1dzcvGfPHjCbnThxAlQBOCFkWwPbudls/uijjziOO3LkCEmSELsJ50T1rpFLMXLm27Jly+uvv/7GG28Eg0GFQrGgMXAYy7Imk+nSpUu9vb12u/3dd9+FTXAIq21ubvb7/Xv27IGMEwzD6HS6W7dupaamXr161efzoarp6AGilkDjYfhDJd/hsHA4nJeXd+7cudOnT1MU9frrr//t3/5tV1dXc3MzJAcEnwSwvmg0Gpqmz507Z7FYIOkH5OZHjxcceXNycq5cuVJSUtLY2BgKhZawrSKWxYInWB8hUhG6lQSxkjAHyIiPcJwmJoYFDyn44oMTZLSLpY+kSJIj6Xgauni9l1iyGCVByeMlIePG9c8qu/8/zrxfC0iZarPZjhw5otFooAJAVVWVQqHIyck5d+4cZE58++23//Iv/zInJwdS/RQUFBgMBo7jJBKJTqe7fv26UqmE+l/IVsdxXH5+/jvvvHP9+vXh4WHIdMSyLGSFVygUR48epSjqj3/8o0qlKi8vp2n6/PnzMzMzDQ0NNpstsbT7//NQSbK9vb2hoQFmd4iLRbIAPm8SicRms928ebO0tPTy5csQhp6RkXHhwoWcnJzW1tZbt26Vl5cnetrMzs5eu3bNYrH09PSsW7cOej6YBiD4+9ixY6tWrXrjjTc2b968du1an8939uxZWAOUlJSA4sKy7ObNm//xH/+xr6+vuLj4j3/84+XLl0dGRux2O8dxarXabDZfuXJFq9VevXo1JSVFoVDApM6yLDyTyclJ8HhJ9IsFeQwGgxcuXNi1axcUk4LC0gaD4YMPPgiHw3/605+kUmltbW1SUhJo58nJyaAqnT179sSJEyzLvvfee//9v/932CdEZwZrQjAYBFdgYmkhCAStJKVpRJgTOJ6UaAXfLN/bSfjdMX8ZiVygGVKsJCmKYCOx+NT42yZEsrhtXhKPFiHIpBIqo/I/97m+HXier66urqur++STTzZt2nTlyhWSJKuqqsBughZj4XBYo9EwDHP69OnMzMy2trbi4mIwYC0YJ6urq8+ePfvGG29ANHM4HAYb85EjR6LR6FtvvQUFktBqGYrlTU5OpqamBgKBnJyco0ePQh+enJx8+OGHwfB0+fJlp9PZ2dlZWloKPSSxV4Bcm0yma9eudXR0QB9DsxvURzOZTJ2dnStXroT08LOzs+FwOCkpCbaDLly4cOrUqWAw+Kc//SkzMxN1bzizXC7PyMi4fv16VlbW7du3wQ/earV++umnJ06c6Ovrs9vtsDeo0WiuX79eFOe9994rKiqampo6evToihUrent7QZYbGxvNZjMYvFHCNGitXq+XyWRTU1OwSkcDiNlsHh8fb2pq0mg0aB6E6S/xVZpMJqfTCSMVGqZg0IAor/fffx/qVLz77rt5eXnILfZb6l3LEqy434NYjUciOi84b8Z3G9mY9UK3jqBlBB+F4hUxzTyuJsRUdvKz/8c3Jr/FXgh2gvn5+Q8++ABCFQsKCvLz8zdt2vTWW281NTVBwQiVSrV+/fqjR4+eOnUqPT19xYoVUIcIRAhGHEEQUlNTDQaDxWJBa1+O46Ae5L//+783NzdbrdYNGzZALcYjR46cOXMmPz9/7dq10WgUItVgcg2Hw9A8uEQwGCwsLBweHj527FhBQQG4rWdlZf3617+22Wzp6emgxCDtkyTJvXv3vvrqq3//93+vVqv/7M/+LDE1GLiygC0/EokVzwQth+O4qqoqsKhB7mpQ06ExMA1DuFJhYeGHH3742muv/fVf/3VdXd0vfvELmqahcmpHR4dSqUSxUNFodOPGjb/5zW/+4R/+IS8vD2rLwZ3CfaHSzTDHsywLswW4C6OvgsFgWVlZeXn5a6+9RlHU2rVrwUH58uXLf/u3fyuTyZ555hlwD4DUnKWlpX/4wx+ys7NBXYCTgPM9TFo8z9fW1t64ceMf/uEfCgoKsrKykE//0gQUbPgfRTByklESUh0hJkk1KYSFWDrIECmwQkykaDERDghhko/EVXaKIGWxBPCx/DMLT/oNNe4/HEUOHz78q1/96v/8n//DsmxKSsru3bvBjl5eXv773/8eSpNkZWWxLFtSUvL73/8+KyvrySefdLvd4E7z2muvdXd3p6SkIKEDJ5wVK1bU19f/+7//eyQS2bdvn1arhU4uk8l27dr12muv/f3f/z0UJJZKpevWrfvkk09u3LgBvqHQ2RZ7cNE0XVhY+G//9m+RSOTAgQNwTuilMDeHw2GO42pqajo7O//xH/+RoqgXXnhBIpGsX7++qanpl7/8JUVRjzzyiFarRXWLQZBv3bo1NDRUXFxcUVExOjqKej64mnzwwQd1dXUpKSmrVq3S6/WlpaW/+c1vbDYbhM6Dih8MBisqKpKSkj766KNXXnnlypUr//RP/1ReXp6fnw9bYTt37vzd7373i1/8IikpaevWrbBrp/wPZDKZXq8H/QmeJNw7KG0ul+vOnTtQjB2NkPv27fvtb3/7//1//59Op4M6D0qlElQonU4Hw+aKFSt+//vfRyKR9evX5+fn37x5Ez0unucVCkVSUpJSqYT1wNKTtVi9YXPMLY3gBUpGmtMI+S3CM0+KJLGiqjQdzyxDEmJpzKDO87EM7jB3kRTBsaQ+m8peRzCSb89JBolDUlLSjh07jh49CjVDHn300dTU1ObmZjSSg3OITqcrLS394x//mJKSYrVaoSIvjI3wypDF5KWXXmpqaiopKWlubg4Gg1KpdN++fb/+9a8hpvyJJ55IzB9KkiTsxlgslkAgkJmZWVNT895770H2SXCUWr9+/fHjxxsaGlJSUkAGEx0s0SYbhHm8//77P/vZz2AqhDiQoqKiN998Mz09PSkpCW4ZeqNCodDpdF6vt6SkpLS09NVXX4UJCOoEJ+ZjIAiipqamra3tl7/8ZUlJic1m83g8hYWFUqn0l7/8ZV5eXnp6OoSel5eXv/rqq6WlpZs2bbp69eqvfvUrKAGr1WpXr15dX1//v/7X/xKJRE8++aRCoYBLwMJAoVAolUqFQiGXy/V6PdTqBokAhyKe5995550XX3wRySA8/8RXmZmZSVHUe++997Of/QwdBmuqUCi0Zs2apqamX/3qVzRNQ3Qs1tq/AlhxvyeUSHC3EcGBWP1nPkKocglFUcw+AcmnCYLjCTamY312OArK+Pb6IciAVCp94oknYEsOLEMURVVXV/v9fkiPCHtemzdvhjKl5eXlkCX38OHDDMOsXr0a3GFVKpVcLtfpdLCznLhNXFpa+uijj05MTBQXF4M9HlKdzM3NVVZWwip57969GRkZHo+noKDAaDTCTH/o0KGUlJSJiYmUlJQNGzaYzeY1a9ZAOZU9e/YYjUZwMABn1sOHD0M2G57nCwsLH3nkkaGhoczMzNLSUrRfH41Gt2zZAsH+er1+3759CoWiqqoqEokEAoHR0dHVq1evXbtWq9V++umnBEGAtg3KzYYNGyAfc1pa2tNPPw3Wu8cff7yxsVEul69btw78EFJSUpBSFYlEysrKoIwiVHrjOG7Lli0ajUYmkz3xxBMymSwajSoUir179+p0uuLiYovF4nK5Dh48mJ6eDj6Ijz76qEajkUgku3fvVqvVgiBs2rQJsmI98cQTPT09SUlJ5eXl6B4h469IJDIajUlJSRKJRC6X792712w2+3y+tLS0/fv3UxRlNpsfe+yxjo6OgoICpVKpVqvBx5pYwvDxXfg48SrrMaVBQpIMFwtFjcQ2sGIZ3Pl4Cmr2szwZsDFO0JCm+tsC5qG8vLwnn3zyzp07sEcPXhYymeyhhx7S6XQcx9XW1qpUKqiyGQqFwM4Ei8wVK1YcOnQoGo0WFRWBtRtNY1BJ12q1isXizZs3h0IhcGGPRqPFxcWHDh0aGhqCqmEsy27ZsgUc6AsLCyE/xqOPPmoymdBCEbW5uro6LS2NpumNGzcGAoEVK1bk5uYKghAOh3NzcyFZU1JS0sMPP9zS0mI0GquqqliWtVgshw4damlp0Wq1tbW1yNs+GAyuXr26qqpqZmZmfHy8srJSLpcbDIa9e/dCsg6GYdauXcuy7PT09MqVK5OTk3me37dvn06nAzGHvXuQGoZhnnzySa/Xq1arH3nkkdTU1Pz8fHkcyHn/yCOPDA4OFhYWwkKIoqgDBw7I5fJAIGCxWH72s59ZrVafzwfl5SHRx969e7OysqampgiC0Gg0SKA4jisuLj548ODIyEhWVlZRURFsxB08eBClvFAoFCCePM/X1NRIJBIQNOQyB/ZdiB2EFQixxIhnViC18YTtJKHQ0GkVvHcm5jZDxrX22J3Gkh1/VnQJIlYpmogESbUlFpCqNMeDS77dGweHLqiSOz4+brVaa2trBUEwm82PPPIIGFPKysrS0tICgcDWrVslEolCocjKygIHwocffhhcUFJSUvbu3SsSiQYHB0tLSysqKtRqdUNDA8w1JSUljz766Pj4eH5+flFRETJUQWwGWJGVSqXb7ZZKpZAmlWXZ9evXQ5jWtm3bINIjNzcXynvv27cPFuSJ7vImk+mpp55iWVYqlR4+fBhli9q+fTvEYkKALHTvRx99FOJoBUFQKpUwpBAEsXHjRpqmS0tLIRgDha1nZGQcPny4u7u7vLw8Go1aLBaFQnH48OHOzs7c3FylUmk0GoPBYHV1dTAYtFqtMpns4MGD8ARgDMnIyHj88cfb29v1en1ifipY6z7yyCNqtToQCCQnJ//sZz8zmUw+n2/9+vUwSxoMhqeeesrv92u1WjgyGAxmZmbu27cvMe+WQqF4/PHHwXR46NAhnU4XiUSSkpIOHz4MWXr27t1rMpnEYjG8ygUpMTD3A9nT00MsIyiKgnLf30RRSZIQosLAP5Huy5/pC6k/Jsx7/7OI9IODJEm1Wg1u4rDQB5c4uVwOu10URUHgI2QxgwoUkCTO6/WiRI3BYPCtt97iOO6v//qvPR5PYigMSZJgnWJZFkLcGIZRKpVwOa/XCwF2UDEOHrjf74fQeJIk//SnP3V1df3iF7/wer2CIMBXcrkcDNuwnR0IBMADAa0Z1Go1CL/X60U3C4MapPQSiURyuRzi7sEY8M477ygUii1btjQ2Nn700Ud/8zd/k5aWBom3YW6GjIrQWpIk5+fn1Wo1uA+GQiG/3/9//+//3b17d0VFBdTCAJUFwvwhtTYkxwQbv0ql8ng88DkknYQQYbfbDQZO0KRVKhX4+UHQLXgpQGZJaAZJkpCvHVl9JBIJSvsDZgzI6AclsaRSqc/nAy8mlOCCZdnEPGVfH7CwwuB7D98AmKL8fj+sSb6hi8cT2M2cIEb/JWZIj21mCXEfdypWhslPC5FoTJXnY9tasYWzmKFkfjKlisj5/xEiddyH5luRSigNA4UMwakUnKohiA10YojqFolEULcI+huERcIaErQEVP0HuhbkvIPPQ6EQmJP9fj9IN0ixx+NBaTdAcKDnJAoOSCvHcX/3d3/3yiuvrF69OhgMhkIh6EKQGx5OIhaLIZ5PqVSCqzokUEdiC41J9HxVKBTgywu9zufzIRlEieQgC40gCCC2EIIGjw7EXK1Wg9sDiJ7L5YI9LrD2QXAL1FiAXyHxh37o9/vh2cJJFAoFJHwkSRIy2X/66acNDQ1/93d/B8MgeneQPARcfuFBgRERhi8w6kulUnDmCQQC8E909ampqX/913/dsWPH7t27E4fHrw+E/CYm17or8Dog+vmr+uqAdh7/gxYTLjt7+23CPxeL3SLRV2jvK26QEjiCkdL5m8js9bFgke9kroMMgxBOjQZPsVgsl8tBBGCKgY0seBrQ/YLBoFKphHFSLBZLpdJQKPTpp586nc4DBw50dXW98cYbf/EXf1FaWgoGe+iT0B/Qpd1u97/9279VVFQcPnwYahjDaIxkE1YIMOnAi/B4PFqtFqzIC0ZgJMhKpdLv94NoQNdCzYZcqOCdgnqjTCYTi8VQJQ08P6EBieeHDg9tgOkG0tTAaaPRaCgUkkgkKpUqEAj4fD7IvQPuZGA7B6GA5IwLlGZw2IN5FokbiAw0A0YJCHyHW4NnvmC+hkv4/X7IeAupt+BVwsgJoxnYIL49rZ2MW16CwSAMp8QyAlvc76lGeDtIf3vcH5eNlYzRVcUHtwe/OhQEAZK5Jn7CsizID0zk4MGCDgOPC1CjUYLnurq61tbW5557bsGWHMgSlLdAQeUcx8HZUHAYKAHgyoL2y7xer0wmg4JHvjgoshP0CTRRgQqSGIafKP+JjQG9H24BLgq3AArN0aNHR0ZG2tvb8/LyYK8TmUAgvzvM2XBy0GMSg5kikYjRaEwsZgRXSbx3aACM1/Ahz/PQElCyUf0/dC0wIyFfhcSHhl5Z4jZrJBJZ4LiMHi+408DfqGGJb2r5ILUSYi0R8f5HKncyZoanwiQdjaWQZuIxqULM950U8wJPkZTyLlVmvlFQLwUvLBSIDJpx4nuEOi+oD8C0gUTyrmsk0Pihq6C+ukAQUN9A51ksOADYCD0eDzQMMtskngT5gSARQCdBGZkSTwuNRGeAHohkEC3hFgwUEEGIngPcDtwjEmQQ0sTUlncV/0TBB9FDTUIPCox2ZrN58btDsobkHZ0QZbVH4on81pA15OOPP45EInl5eUvZJy0h4oPnCLWVNGQKnqmYEDHi+AoYgWooUFTqCjJjdSxD03d100hYYGpDYaPQJcDIAl16gSwkjpNwvFQq1Wg077zzjsPh6OnpMZlMqamp8Jaho6L+gCav06dPj4+PP/vss/CiF0gc9JYF100c8BfcC5IOuJ3FPQ21AVbUqDcmDilIeBecHzowEi7QjxdkmI1Go06nExbVaDZcPJctbjxqT6K4JY5LaPZB945EJvFVoiahYQq9yruOnJgvC1bcPwfYQ3RdJ6LzsaR1QpDQbSRElngWuu8FKCN7Yt7WxPKBCz5JTASLPg8Gg2vWrCkvL0eVzxZcIvG3dz0bmtETP2RZNjk5GUarxK8WJMEF9TdRdBcnw0a3s/gWQFVat26d3+8HB57t27cvGKQW/BC1FqWQJwgiNzcXfB4SbTCLn+TiBie2BBXaTGzkPR7aXe/xHg8H/b04qTyxTIib+uR5hPkxYvJPRHQutnKmxEKUIDiaEPMEG9vD53lSCMcTubN+0phGmLYRlPSbLQqzmMSHf9dOsuBd3/WYe7/xxUJ01zOjDxNbgrTSlStXqlQqFLu54Jx3lcR73A76PPGPL/UcFktNYsMWP5nFopF4UVRsYcGNgA/x4jIUX3jCu76CxGUYSZI7d+6E2MFlImg0Q6aUEuMtwl0NkCRFsGHCXEBlrY3lluH/H4Xs2wY9/M8bSD+v5yzojeBstn///vHx8bKysvXr10Nl8bv2B1Seb+fOnch5/d69OvG6dx2B0eefJyaLp6TFxywQ3gUnT5zjFs8IaGvu83SABc1Y3PLPE7fFt5YoMvd+AveYEzFfFqy43w2BJyiJELKTnsZYEXaeJcRmQlMVVw6470kOzQUFie4qA5/3CRLC4uJilUqlVqvv6nFx/+dP/ArW6+np6RaLBbThux52n5dY/HniLcCF9u3bNzo6ajab09PTF7ii3vXvxIGSpum1a9cmJpW//ztNbMkXXutL3eOXOuEyQiAYNWHYQvAhwt1IBEYIzkeEvESUiikc8ZjUmDDGkkFKCU0umbaN0FbEN8S+Xe+1u06i9y9u9zjt5/3zq4l2dXX1goImXygLX9jUu37+lZ/DvbvxvU+VmFou8UOe5zMyMqDY6gLrw5cdcBL/SdN0TU1NVlYWREAuE7njWUqXwRltxEzf3bT2CKlJIrOqCaWJ4CKxT75DFthcEj+8/xEVZh+j0bhv3z7IcQ5V0j6vy8HOc1VVVXJyMrzo+7nK531yj6beT4e/n9nwPhv2FSag+xG3LyvIP7wp7DsC+7h/XiItsTD1ETn2aszKxwUI4y4i7cexfDLfQum4BwhkWf42piWUKp74lgF3c8i1hzwZvhSJ4/UPnAfq404k1ErlYoq7s54IjQr+ecLvI8JsrJQjRRKcWBDJSKmVtG0lLTWx3bBlJI9fE/CUXZIZx79/Nw7RwOC99m0Mj9+Vj/tdzsqP3ebbji4UHEEgRFKqcDuVvirmVLOUQ97hlYlEovuZFOBFQ2pjrFMuJ0js4/5DQogXXZok5y8SJBfzaKeVhGpVLACOC3/HRohvm8/b7PtG+G4UCBiU4Ua+WvTYD1DR+R4TTw1JMoS6nJBnE5yPDEwIzh7COSZEvQRFxaqvq0sJeToh1cZKK/yHLzzmh9yZv427Rv4GxLIiljqGMtgEdbLgnoiZpeDRxbK5c1RaBZVS8dk/lzKJZqMvnBTA2wpbgjFLCKy43w2BJzztsSyQhIgQIoSyQFCVkN/ydvwD4dsbsL7VJcHiay3wyflSLJ998GUCH9/yUsSLPgqEJJmUZRA6J8GFYh1KbSYkyQSjivnM8NFvNR3kkuMH25O/pdEGXNuX1yONR5IoDITRRrjG/zOZDBslTHmxgFSxNPb30r/lLzUpYMUds7TAivtiKIIPEO6GuFogipnYNWsIiYEQosvM3P6tDlXf5SD4NSdXPF5/H/NgCNxnCaRJMaFIJ5SZ8ZdExmrBCBzB+uNfLTd5/Jr8YHvyt3TjS7xCwucQWxUzlCWXm+wkfLNxOSJItZW0rSFVllhwKrmoqtkS5EtNCj9YwcEsUZbjwPQ1iRWNCxDBHsjjTohTBFXVZxXmMBjMdwQZUyDIeIklQYhXduTiaS742CfwFQaD+bKQZKwqqi6dTC4hxHKCFpMyNWVbS5myY/K1LLR2DGZ5gy3uC4g7/AlRQgjEhjAhQqhXkvLUbzttxTfOXTNJfQeXW3xdqCNDfOc8qOtiMF8KlLjtgUsx5gcEJaLSVgi0SAi6KHUSaS0gaNH3J9nxl+r8ibPPguO/rATdQxi/swkFz1yYLwQr7neDFBG0igg5CGkKoa2Oxap+txltvz5QLA1lpf22gUpsUNsZgrrQV1AehfjOEYvFULLuu780ZhnzzSrTgiCIxWIQ1cQP4fxQ3xenPMJ88/AcqTSSaSuEiJ+U6QixLLaj9eCWiDBWI+WboiiRSAR1Ru/9QygzBGeANDKJYz6UB15QIeiuJwGJE4vFd70oSZJisfj+z/N1RhWJRIJKMdznb1EVJ8wPBKy4LyC+L08rCFVlrO66ei2hyFly5nYIq4IR7bvRXHmej0ajkEoZhl30FdRPJr5zQqEQ6D3f/aUxy5jEoiRfH6iPCMmkEz8E1QHmb5rG3guYbxoyHi4iVZMyTaxCKh/3QHtwSKVSVEAUqlmHQiGwB937hxRFoUln8ZgPSR5Bs/884Ldga/+8i6IJ7t6NQZL7ZaEoCqXB+VIzJlq3fGdGOsz3AbxKWwwfq8Vo2kukvEiY98VSzi01oy1N06Ojo8PDw2C0+FavBYqFx+Pp7+/neX54eHh6ehquC/WQ29ravuO6g2Ck7O7uDgaDkOD5O7s0BnOfgHEuHA63tbWNjIwkaudgQqNpenp6emho6N6pvjGYr8hnKWXifzxonY8kSSjHATZyiqL6+vqcTue9V608z4tEoqGhobGxMY7j+vr6/H4/kheKopxOZ19f3/1khASjdU9Pz+zs7AKJA4W+q6vrC7M2fR05RVVj29vbYf1wn79KrFKM+YGAFffPQZpKqCsIiYn4XgKpZ8EMgDYHIQEW/LOuru7cuXMSiQSOZOMgCec4LhqNJhZPZlkWTnWfDeB5Hs4JQ+f09PTNmzd5nm9qaurv75dIJFAXyeFw/PGPf5yZmQGTwILrJt4OnA01AO4usdmJF10wSKEbh5OTJBmJRC5evOh2u8GB5/POs+AJfKkNSswPBOhXsEvO8/zs7KzL5UKilNiREqXyrn1pQQemKOr69evvvPOO3W6HFSao8lNTU8FgUCQS9fX1NTU1wQJ4cV9dIEcgBegA1Hi4VqKAQyPRr5ZZaRLMl4GP+7U/yEEPbMZHjhz53//7f//P//k//+Zv/uaXv/ylx+Opr68fHx+HTePEiQP1c9hYFolEFy5cOHfuXDgcvn79+vz8vCAIcLBIJLLb7Tdu3ADhWjwRoEpY09PT8O3Ro0dbWlrgokjKoAzWxYsXI5EIsuIjcUZOPqFQaGpqKhQK3VvqE2crdCPQBoIg5ufn//jHP9rtdjDeLx5eEu+C53mz2dzX19fV1WUymfDk9cMBu8rcFSGevIKJBad+/9Y2YI2DWnpSqTQajYZCIZ7nJRIJRVF0nKSkJDR/y+VycPgOBAIwVCkUCrFYHAqFYCSiKEqhUDAME45zPw2QSCRSqVQQBJ/PR5Kk3+8fHx8XBGFqakoikcDmHYzIBQUFNE1LpVKRSMTECQaDiV7vYOqAIoLQAGgh3BHP81DLE10U3Qj6uVQqhYgisVgMB3McNzw8DKeSSCRyuVwQhGAwCIOsSCSSyWQkSQYCAdhhpGlapVIJghAKhfCeIyYRuVwOXqeBQEAul9+4cUOr1dbU1IBlDvotiBJN03K5nGVZmUwGFfsSp1JwZ5dKpbAbzvO8TCZrbW3V6XQ5OTkwhYO5sbGxcevWrQqFYm5ubmpqSq1Wy2QyuARs6yuVSlAU0F4WkoJQKMQwjFwuBw8chUIB07xGowH5CoVCIA6RSAT96n6kHrMc+V4MdBRF3bp1a3R0NCkpKRgMglY6MTGRk5MDA7tSqRSJRMFgMBKJwNAdDAZJktRoNCRJJicnQ41bsLsbjUav1wvbrV6vd3x8HNxvJBKJTCZLnD44jlOpVOPj411dXfv27QsGgzabTa/XcxxH07RSqQSRASV7eHgYpg+lUsnzfCgUkkqlaGRgGIYkycbGxp07d0okErg6XEUsFsNkDROQWCyGbQSJRBIOhwOBgFKpHB0d7erqevLJJ51OZ15eHrjaw6wELkAwvMDoAbM5TKM9PT3Xrl0jCEKlUlksFjxz/UDAivvnAQLwvdPakSuIz+eDgQl2GGH2RdX+HnroIZZlYRYPBAIej4eiKLFYDJqEz+eDUB7YExQEwe12wyf34xZPUVQ4HAaVHcYgNKZIJBKRSAQWCI7jLBbL008/LZVKfT4fMu+JRKLEfUAYVd1uNzgjQgPQ3UGUUuJF0Sfo58FgEBkkRCKRWCwmSVImk4HjIAyOUAEb9B6WZcEwIxaLkTFmfn6eIAhoGzZdYABY3bndbpqmQXVobm42mUyrVq1CggNdmqZpjuOgxy7updCBo9EoKA3Qz2dmZpxO5+7du3Nzc71eL3TOqamp+vr6/Px8s9ksEokkEonH4/H5fDDfw0WdTueCvkpRFEgBFG8Ph8OweIaW0DTtcrmQfPn9fpBc+BVyk8VgHgiCIGg0mkcffXTbtm3g66LVamEygm+9Xi+asPx+P3R++JxhmB07dkil0tnZWdCPHQ5HKBSCmG80McH04ff7FwimIAiDg4MNDQ3V1dUqleqRRx5hGAYUdCTaEokEJhSQUBBVkUgUCoVg/gVRstvt9fX1JSUlWVlZSIGG7V90XfDIB5l1u93wCcdx/f39t27d2rVrl0ajeeaZZ0A1JwgCxBYNL2DwgtkcPrx48WJLSwt49j/zzDMP7h1ivlPweL3EAHVzamrqwoULqampJ06cKCoq2r9/v1arvX79+vT09Pz8vFQqzczMjEaj27ZtCwQC586du379us1m+9GPfgTDzcmTJ8E2sG7dOoZhvF7vBx980NnZWVtbu3fvXrT3d48GNDY2Hj16VKlUPv744wUFBcjHLtHlDpSejz/++Ec/+tH169dZlh0fH+/r6zt48GBlZSXa/hOJRE6n84MPPhgeHt6+fXttbW00Gj1y5Eh6enpdXZ1arX766acNBoNIJLp58+aZM2cyMjIee+wxuVwOQ5tEIrly5YrH44lEIteuXTtw4MCGDRtQa0UiUXt7+9GjR2Uy2ZNPPpmWliYSibq7uz/55JNgMPjEE0/k5+dzHDc2Nvbuu++KxeKDBw9mZ2eDqf47fKuY7x3QgUmSPHPmzMWLF4uKiqAbt7W1MQyjVqv37Nnj8/lgX3vnzp0bNmyYmpo6efJkUVHRBx98kJube/jwYYVCgfbHwb5+7NgxkiSffPLJ9PT0jz76aGRkBD5Zu3Ytx3HhcPj9998fGBh49dVX/9t/+28Mw/A8f+TIkRs3bjzyyCPV1dWw5nznnXcCgcD+/ftLS0thua5SqU6ePBmJRB5++OHOzk4QBLlc/sknn6xYscJms7322mvj4+Pr169/+OGHT548qVQqN23aJBKJTp06FYlEdu3ahXPXYB4sCoVCo9GAeQWtUUFT//TTTzs6Ovbv319TU3P69OlgMPj44497PJ633357165dY2NjFEXl5uZKJJLh4eGPPvpIoVA88cQTGo0GzTIURTU1NR0/fjw9Pf2JJ54A07tUKh0bGzt69Oj09PSvf/3rn/zkJ5cuXcrMzKysrBwfH//www/Hx8d37ty5detWaAxYwd9///3U1NTdu3fX1dWdOXMmPz//4YcfpigKJPc3v/nNK6+8kpWVBdvdFEV1dHR8/PHHZrN5//792dnZt2/fHh4eVigUp06dqq2tfeSRR7q6us6dOzc+Pv7aa6/t37//8uXLW7dutVgso6Ojn3zyydTU1MMPP1xZWQn+qHK5/OrVq1ar9bHHHjOZTFlZWceOHQuFQo899phIJIJNuQf9JjHfOt9HizLm3pAkybLsmTNnLl++zDDMrVu3bty4IRaLp6enT58+3d/fL5PJeuLI5fK2tra6ujqRSNTc3AwT9s2bN2/cuEGS5MmTJ/v6+iQSye3bt7u7uzUazblz51paWsAzfoFTHRoBGYYZGxv78MMPeZ6fmJg4ceLE540UYAuvr69nWdZut3/wwQfzcS5duhSJRFAOAZ7nz54929nZKRKJTp8+3dfXp1Aorl27dubMGZIk79y509LSIpfLR0dHT548SRBEc3PzpUuXwJoOZ5ifn//4448HBgYEQfj000/Hx8fBYkHTtN1u//DDD1mWnZqaOnbsGNhLjh49Oj8/D8sVj8fDsuzx48dnZ2cdDsfx48dDoRAe+zDgRtLT03P9+nWtVtvc3HzhwgXYzwEIgrh06VJHRwf0H7vdTpLkjRs3zpw5IxaLW1paLl++DHZBWJ3Ozc198sknPp9vbm7u2LFjfr9fIpEgBQUuCpY82IInSVIqlba1tY2NjQUCgVOnTjmdToqiTpw4MTw87Pf7jx496nK5ICEGTdNOp7Onp4eiqJmZGVDiI5FId3c3x3HHjh0D+aqrqxsbG3O73S0tLXDdpqYmr9eL9uIwmAeFTCZTxQHDOXxIUdSVK1egu8LYrlarr1y5EgwGx8bGWltbjUZjd3d3b28v7C1fuXKFZdm+vr7z58+D0yNsNNnt9mPHjkHo58WLF5EtHxwsJRIJ7L62trZOTU0JgnD69One3l6SJI8dO9bX1wcuqQqForm5uampKTU1dXBw8NSpUyBB165dAxM4SC4KqIXor2PHjoEbz6lTp1iWdbvdZ86caWxsFIvF586d6+rqgm1qaEY0Gr19+3YgEOA47tSpUyMjI7B0n5ycJEnyehyCIG7cuNHb2ysSidxut16vt1gssGf+QF8g5rsDK+5LD7B5z87OMgzz0ksvZWZmXrt2LRwO0zTt9Xqrq6s3bdoEm3cMw1y+fFkqlT7//PPFxcX19fWgSWdlZf3FX/wFRVHt7e0cx926daugoOCv/uqvLBaL3W4HbQP2GeVyuUKhUKlUoKnASArevS+99NL+/fubm5thO/6uTQUXc9jBn5qaqq2tPXTo0NDQEKQLQBlprl69umLFiueff55l2Zs3b4KreiQSeeaZZ4qKipqbm2Uy2a1bt6LR6Msvv7x69eqrV6+Gw2GUmE8mk01NTeXl5b300kuglIC/DUVRc3NzBEG88MILjzzySEtLSyQSGRwc7Ozs3LNnz+HDhwcHBycnJ6empjo6Op544okDBw709/ePjo5iPQYDTrHNzc0ikeiv/uqvVq5cOT4+XlZWZrPZSktLt27d6vF4rl27tmHDhhdffNHn8zU3NysUCvDLevHFF4uKiq5cuQJbNxCt0dnZOTAwcPDgwQMHDrS2to6Pj2/atMlqtW7ZsmXlypXg1ysSiTZt2mSxWPbt25eWlkaSpMPhqKioePLJJ0dGRsbHx30+361bt/bu3fvkk09OTU319fWBYHIcl5SUFI1G/X5/IBCYmZkJBALgEmMwGIaGhjZt2vQXf/EXIpGoq6srOzt7bm4uEon4fD63222z2bB7GOaBMzk52RtnfHwcOiTDMD6fr6Ghoby8/Kc//WkwGASfFkEQWltbm5ubbTZbRkYGCA7DMHNzc8Fg8Mknn1yzZs2NGzdcLhfMZQzDQKqWV155Ze3atSCY4LVisViqq6vT09P3798PTu1SqXRubu7atWtr1qx59tlnw+Fwe3s7pLsJhUKnTp0qLCxcs2bN9evXBUH48Y9/XFZWduvWLY7jtmzZYrFY9u/fn5ycDOZ2mqY7OjqmpqaeffbZjRs3Njc32+12qVQ6Pz9vsVheeeUVsVh86dKlrKysiooKq9W6b98+iJmBTfWmpqb169c/88wzU1NT7e3tUqnU6XQqFIrnnnsuJSWls7MTBo2cnJzi4mJwpMEmpx8IWHFfeoD7uFwu37x5c1FR0c6dO/1+/9zcHMdxmZmZe/fu1Wq1cGQkEhkdHd29e3d2dvbu3btLSkr6+/v9fv/27duLiopqa2snJye9Xi/LshkZGRaL5amnniorK0vUicErHeWmgEtbrdYXX3wxJydn1apVarV6bm7uHrmrQIGORCIVFRWVlZWrV6+WyWQo5ZZIJJqZmaFpeteuXfn5+Vu2bBkeHvb5fHK5vLa2tri4uKqqam5uLhqN9vX1VVdX5+bm7tixIxqNgq0RFhKhUCgnJ2fdunXl5eVr164dGBiIRqPgFGgymV544YXc3NzKykqtVuvxeAYGBnJzc9euXVtZWQmn6u3tTU9PX79+/cqVK9PS0gYGBiAo9jt8pZjvIzzP+/3+1NRUvV6/b9++zZs3K+NotVqTyTQzMxONRrdu3QoT+dDQEMSNbdu2LScnZ9euXZAfBtaQDMP09fVVVFSsXLmypqYmMzNzYGDAZDLJ5XKDwaDRaJB8GY1GqVRqNpvlcnkgECgpKVmzZs2KFSvMZrPH4xkbG1Or1Vu2bCktLS0qKurt7YVFZjQaNRqN4XDY5XIFAgGQSjDCyeXyffv27dy5Mysrq7S0dGZmJjU1NRqNBoNBECKTyYQDsjEPEFjcXrly5c04p0+fhuhMsVg8OTnJsix0+DVr1sB+cmlp6YULF7q7u1evXo0yKYE3eW1tbWlp6ebNmymKcjgcyAjV09Ozfv36goKCHTt2sCw7PT0NfmgSicRgMMhkMovFAolcIBeNTCbbsWNHfn7+vn37IJGDXC6/devWzMzM/v37vV5vf3//hg0bioqKNm/eDKKUlJQkkUjMZjOkbYCN8b6+PpDfDRs2GI3GoaEhiqL0ej1EttTW1o6MjIhEIp1OJ5PJzGYzTFsSiWRgYMBoNNbW1lZUVGzYsGFoaCgajYrF4g0bNlRUVKxZs2Z6ejoUCu3Zsyc/P99ms+3fvx+L8A8H7OO+9IARQafTpaamEgSRlJQklUpdLhfDMAaDQavVut1uWO673W6WZbOzs0mSTElJ2bVr1/Dw8Pj4+J07d+bn53t7e3t6egRBMJlMn3zyiUKhqKysFIvFYCZkGGZ0dBRcYIPBYG1t7erVqyHNlsVikUgk9fX1Y2NjkMXlC9vM8zy0E/yDPR4P+mp2dlatVlutVpqm09PTr1696vP5pFJpcnIyRVEpKSmCIMzOzgaDweHh4bNnz4KZcG5uzmq1wvgYjUatVqvRaBSLxRkZGePj45AHl+M4s9lMEMTt27cnJibAij87O5uenq5Wq4PB4ObNmyUSSWtrq8fjuXTpks/na2trS0lJwVXoMKANmEym48ePf/TRR7W1tVarFRRcCPd0u90+n6++vl6pVI6NjYGWL5PJbDYbiJtMJnM6nRkZGZC3bn5+PisrSyaTSSQSq9UKe0FwqsT+BnFmqOKjyWTSaDSRSESn00H4qd/vv379ejQabWlpyc/Ph99CMo1QKDQ/Px+JRMrKytxudzAYlMlkGo1GLpf39va2t7f39/cbjUZIOQXtJwjCZDI9kNrGGAyAAqwhqiQxstPv9/f399fX10/Ege69bt26f/mXf0lNTS0qKgIzM1iUlEplRkYGwzAWi0WpVM7Pz6NTjY+Pe71ek8nk9/vBXS0zMxPlj0dZFuB4h8NhMBisVmskElm1alU4HOZ53uVyffjhh5s3b87KynI4HIFAYGxsrK6ubnBwsKurKxQKgXsbqgAF07Tb7S4sLIRwW4PBAMtmmUyWmppKkmR2dvbFixchKQ3IPor7mpmZ0Wq1Op2OpmmbzXb79u1QKKTVas1ms1gstlqtzc3NUBOqsrISfrI4EyVmuYIV9yUJJIKkadrn84EzLhSNAz8/MJBDdgtwnoMPCwoKBgYGpqen79y5Mz4+Pjo6Chtzq1atunPnzpEjR/r7+/fs2aPVasEHPRQKjYyMhEIhv99fUVGBLNwul+ujjz6amZkJxbkfNReMjtBIkUiUWDva6/VCDB9UjIPDIE9OMBiEm4JA/rGxMYIgwuEw5LNLfBpgIw8EAuCZA6M5RVFut/vIkSMzMzOQaJLjuFAoZDabwakgOTkZNkBdLldDQ0MgEAiFQiqVChsgMWDAg33w8+fP9/T0HDp0KCMjA2Vqh2yMra2tYrHY4XDYbDZwV0PiJpPJIGkd7DhFIhGFQhGJRHieVygUfr8fyhtDGAm6LggviiqBXDQsy4LtEISxoaGBZVmXy6XRaFiWBRVfp9NRFDU9Pe3z+SoqKubn5xmG0el0CoXik08+uXbtmlKphAASrVarUqmmpqb8fr9KpdJqteBU80CfN+YHDUVRZWVlq1atCgQCMALD5xzHzc7OtrS0TExMTE1Nmc3mSCRis9kIgtDr9VqtNrEigVKphKRJ4D8ZDAYhpQykYpyamtJoNMFgUC6XI98wVHsBXZHneZ/PBzkf/X6/RqNRKBTDw8Mul6unp2fv3r2CIMBUMjIyAuFbMpkM8lEmSi5sI8BM7ff7IRYWdGuQZVhXw1IcNrcTp0VoPMuyYMaCOgxSqRTuBZ6YIAgul8tkMpEkCZa7B/HqMA8A/KaXJGBgQCnhYPJOtB+ghTscBvv1YIFQKBT5+flgeFOpVCRJrly5UiKRnIhjsVj27t0LA5PRaNy/fz/kgbbZbKBSiMXi5ubmK1eubNy40Ww2OxyO+/QqAQ0Gkj8imwQMQBzHoWBT+Bs+R8dDiq6cOBzH2Ww2nU4HiS/REAk+/ZDxHSL2xGJxW1vb5cuXa2pqkpOTZ2dn4SuWZWH94PP54CdarbasrMzr9aalpeGsMphEF6wf//jHZ8+ePXr0qFarfemll5CUQZb0iooKgiAyMjKMRiPSBqByMJJKOBvoBLAQBalEMpvY2eDvRLsdCA58C0p/eXl5IBBISUnJzc0Fxzae5+VyuU6nGxkZcblcq1evrqurUyqVVqs1GAx++OGHKpVq3bp1sC8vFovT0tJGR0dZlk1LSxOLxfcIU8FgvhsyMjIqKyshXyqqUQobvOXl5bArq9frGYZxuVwSiSQUCiUO1LD1CpMd1DZC8gXTVlFRUXFxcSgUys7ONhgMaNoCEUss0Qo5VSFSPBKJwD6zRCLJz8+vr6+vra0FTTo7Ozs/Pz81NbWiokKpVEKSViS5AGjkYrE4EolAvgQ4P/wXNPvEuRs1GOVZRpMamjrR1gScBO2Qf+dvDPPAwC976QFSHQwG/X4/bJBFo1GlUplot4N9Oo1GAwZycGO9c+eOTCbLy8urrq42Go2wvochoLCw0Gq1vvXWW319faDdQnGKsrIyFKgKijvDMP39/StXrnzsscf8fv/58+eRAv0VbgQMJ4FAIBgMqlQqsPwpFIrEewFlRSwW5+fnr1+/HgZl5IYOrfX7/ZFIBBLG0zQN30JTS0tLH3300Wg0eu7cOYZhtFrt/Pw8mDB7e3tVKhVMCZs2bZqfn4dh9wtLW2N+CIAUpKamPvHEEyqVqr29HfIxw/SpVCpVKlV1dTVSwX0+H8uyHo8nNTUVCjCp1WqYmyUSiUqlgqzMFEV5PB69Xv95IaGJeWYWoFKp9Hr9pk2bwMAG9kIQYZ7nU1JSent7pVJpYWHh66+/bjaby8rKxsbGSJJ8/vnn8/LyBgcHYbiw2WyNjY1SqbS8vBzvL2G+J0DPT+yNIpHIZrPV1NTI5XIQJZqm79y5A2UQJiYmkpOT0Qzl8/nA7QS2gtVqNSRLBbfyqqqqmpoa+AQWz8jClZjFmKIog8Hg9Xph43dyctLn88E+1aFDh95+++22trZ169ZJpdKioqL169fDprdSqQTnNyS5cBWZTObxeCDKNhQKaTQagiCgoBKsQMRiMVj3FzwHrVY7MTEBBac8Hg9sJtx1WFiw8sf8EMBWlqUHmNIdDkdTUxPE10ciEVTvDY4Bc7VCoYA055Cf7sSJE6mpqRRFDQ8Pp6Sk9Pf3X758ORqNvv322319fVVVVQqFArxT0Ekgq4xSqURZZWDcYRgmOzt7eHgYSmAkVmJaYLoDSwC0Bz5JtEmAQWVmZqarqwuyXKlUKqVSucAeKRaL9Xp9Z2enTqfjOO6jjz5CLjqwK9rR0TE4OBgOh2/dugXhfdAkaGpOTs7IyAgUvEhOTm5tbZ2dnfX7/R9++CFk1RgeHg6FQgaDoa6urr+/H3Ykv6v3ifk+Ala6EydOXLx4sbi4OCMjA2zbYrHY6XSyLAvRopOTk+np6ZCSValU+ny+K1eu0DTd1NTk9/stFgsyriclJTU2Nvp8vsnJyc7OTgjhWGyfg0g4l8sForRAalJSUmZmZubm5pKSkq5evdra2gp9FRbqkBVKr9cjtxmz2QweuikpKZAUD4yImZmZY2NjU1NTaWlpeH8J88CBLaxoHLAogaXZYDCEw+HJycnU1NS2trZbt27RNN3Q0LB27Vq9Xt/Q0ABDPRiheZ6/detWJBLp6emZnZ01mUxgviFJ0mKx9Pb2arVajuOOHz+OfMPAlcXlcsGEArOY1WodHx/v6emhafrYsWMQEQs+pbm5uWfPnlUoFDAfaTSaaDR67Ngxr9crl8uDwSAUa0PTtNlsvnXrVjAYtNvtg4ODSUlJBEFMT083NDTQNA2DhlwuF4lEkA8K2sCybHJy8tDQ0NjYWCgUqq+vNxqNsLuONuIStwgwPzSwxX1JAsHvnZ2dH3744ZUrV7KysjQaDbhog2CDSzdJkhUVFZcvX/7444+vX7+uUCjMZnNSUtKJEyeCwWBdXV1qaurWrVt7enoGBgZmZ2chUh6ZH3ieR7XQUdgQy7JZWVknT5783e9+197e7nQ6YcCFLc5AIJCoB0BxO9D1kRHd7/cjIx/LsgaDITU19dNPP4Wyz3v37oVs62ARAUfDaDRaXl7+hz/84e2334ZRb//+/egSUB718uXLbW1to6Oj27Ztg9qr4XA4Ozv7/fff//3vf9/V1eV0OoPBYG5uLmTGZRhmaGhIqVRCcN7rr79uNBpPnDjx/PPPw6bkA3q3mO8FYHubmppqbW0ViUTXrl3LycmRy+VWq/XkyZNXr17Nzc1NSUl57733RkdHP/roo9WrV8NU2tPTc+TIkevXr2dnZ2u12mg0ClUbCwsL6+rqjhw5AmvjnJwclmUTZQE8BGAiP3XqVFFREVRTh28DcdLS0pRK5Ztvvpmbm3v8+PGHHnoI7QDwPG80Gufm5sAGqdPpurq69Hp9JBKRSCR/+MMfrFbr0NAQLH0tFksgEOB53mq14shUzAMnEAhAKjCkm0I+U7PZbDKZPvroo+np6ePHj1dVVfX09IyOjr788svNzc0ff/zxM888AymSwAGyv7//448/bmpqslqtJpOpu7sb+nlxcfEbb7zxzjvvQGrFrVu3wnUh/tvn8506deqJJ56AGBKz2Wy1WiGDe2NjY3FxMUEQTqczHA5v2bLl5z//eVNTU2Vl5TvvvPPWW2+NjY319PQ89NBDKpVKIpGcPHkyOTlZo9HAfFdYWHjjxo33339/enpaJpNlZma2t7dTFHX16lVoye7du1mWTUpKcrvdp0+fXrVqVTBORkaGQqE4efJkUlKS3W7ft28fhIHBtAgjw4N+aZgHBra4Lz1AD0hPTzcYDG+99VY4HN62bRs4w6EE5KI4kUhk27ZtZrP5d7/7ndPpPHDgAM/zu3fvpmn6tddei0Qi+/btUyqVe/bsGR0d/dWvfiWXy6urq2Hdj7zSka858iNcuXKlTCb7zW9+I5PJ0tLSwJcXTPJisThxRw/lcYf2wIeoeDvKa3ngwIGRkZG33norJyenuro6FApJpVLQSCiKkslk4XB49erVxcXF77333o0bN5566im9Xo9K0wUCgRUrVkxPT7/77rtlcWCHkWVZ8D78zW9+A1uufr/fZrNt3769rq7u008/3bp1a1JSkk6n27Nnz7Vr195///21a9euXr06EAhgewaG47itW7eKxeJf/epXY2NjNTU1NE0XFhZ6vd5Lly7JZLIDBw5MTk6++uqrkL/Z6/Xq9fq8vLw33njD6/Xu3r070V2+oKBg48aNx44du3Llys6dOyHtukQiQQ4zIA4ymQwiYoeHh6VSKZJoyFmhUqn279/f2dn5hz/8ITc3d+vWraivguJuNBohgC81NdVoNIInWGVlZV1d3eXLl4uLixUKBcuyUKVSo9GAMw+2uGMeLGhSQJ/AxCGVSvfs2eN0Ol977TWlUrl3797W1laz2WyxWCClTH9/P1isIU9xTk7OkSNHBgYG9uzZAzkPJBIJy7IrV64sKyv705/+dOPGjYMHD1qtVnCCZ1nWarVClW6PxwO1n9Rq9YEDB3p7e996663CwkJQppVKZSQSKSkpycnJOX/+/IYNGwoLC999992GhobDhw/r9XqRSFRaWnrz5s2xsTEQyWg0WlRUtGrVqiNHjjQ1Ne3evdtsNodCIQiu/e1vf5uamlpbW+v3+9PT000m07lz58AtB5YTu3fvbm9v/+ijjyorK0tKSsDjDk2L8HwwP0zInp4eYhkB/qMQ5b0sjaaQQ2ZoaOjf/u3fXnzxxYmJCaPRmJeXJxKJpqamIpFIeno6z/NTU1M8z6elpQmCMDQ0NDo6qtPpioqKwFV9cHBwYmLCYrHk5+eDPwkYpDMyMrKysu7HS6Svr29iYiInJycSiaSkpLAsC2kW7XY7ZLsDQ2M0Gh0eHs7JyYFydMnJySRJDg0NQaIriLmhaToajXZ1dXk8HpvNlpqaynFcf39/cnKyUqkMBoPj4+OZmZlQnnpwcFAsFpeWlkLNaoIg5HL5H//4R4fDsWvXrr6+vsLCwuTk5EgkAu5AMpmsr69vfHw8JycnGo2aTCa9Xj83N9fd3c2ybHFxsU6nA/N8Z2dnJBLJy8tLSkr6wRaOpigK8nsqFIp7dANQMf1+v1qtXpZShizugiAMDAyMjY0ZjcaCggKJRBIOhzs7O2UyWX5+PsuyXV1dc3NzGRkZubm5drv9X/7lX15++eXR0VG9Xl9QUIB0EfCBcTgcvb29FEUVFRWpVKpIJAJnhuQwKCgNUrUWFhbCRlZ6erogCKOjo3K5PCkpCfqqz+fLysrKyMhAfRXscENDQ8nJySqVanp62uv15uTkQDbV7u5u2HAjSTI5OVmn0/2P//E/0tPTn3/+eY/Hg5ep3zEkSXo8HkjqdQ8JgugdMF4sY+c9kiRHRkZUKpXBYACLMkVRQ0NDGo0GqhP09fVNT0+np6fn5uaOjY1Fo9Hs7OxIJNLb25uamgpZTQ0GA5RNGBkZEYvFsEadnZ11Op02mw2qaEOl8JKSEqVSicoVQb6y6enpsrKyyclJlUplNpsDgQBMSdnZ2enp6T6fb3x8PCMjQy6X9/f3Q4q2kZGRgYEBqVRaUlICLvjz8/N9fX35+fkwu4ELkMPh6Onpgegyk8l06tSppqamxx9/vLu7Oysry2azwV7BwMCAx+PJy8ubnJwEEfZ6vb29vX6/Py8vD7bI7Ha71WpVqVTz8/Nzc3Pp6en37j8/cMj4kIhijYhlBFbcl6TiPjg4+Mtf/vKf//mfIeoUHEtgGvB4POCbTpIkZFHUaDRgkPB4PGBmUKvVoJS43W7wuoH0MhBa94VtAMsfBO9D0kmYWiCxI6h0KDOMWq12uVwKhQKi9wiC0Gg04XAYefWAsqLVakmSDIVCPp+PJEmtVuvz+SBPrUqlglIyKpUKPHp9Ph/oK4IgyOXyt956a2Zm5uc//zncILRHo9HAY1Gr1aip4E0EtbUhrxak1pJIJOBYDw34wWbYwIr7Yt1do9FAR4VOCIUIQFIoioKFH+xcT01N/cM//MMvfvELi8WCpDIxnEMul0MgGkSq0TStUqmgvECid5lUKoU+n5gLVaVSQQ5TiHOFbJXwFWowCDtIB8Rzu1wuKCYvl8tR3sn5+fn+/v7XX3/95ZdfLi4u/sEuUx8gWHFPRBAEtVodiUQSJwWYJoLBIMMwUKEMsh9CfVMIAtHpdF6vF/ZyQ6EQjFoikQgebzQahbIJbrcbLgFH+v3+BXEdEMQF8xSslkUiEQSSRiIRj8cDUyScU6fTkSQ5Pz+vVqslEgnYfUCIpFKpQqHweDxIpiD3FGyXgUSfOXPm5s2b//zP/xyJRGCUgIkMMkmAxR3mPrFYrFKpwPEVEqAplcpAIABpGKRSqdfrXcbD79eHXL6KO/ZxX5KAPgFjOsSkwhCfmOAC/Q1pqlCFCzAMJH4SjUZnZ2fhk/uxvfE8D+eEEQeuAooI6P2J2evm5uZomgZPd9Qe5HuDtECHw4GccwiCgGqsIHhwBnB8R+dPHHZhFJubmwPbIaxJ0BkWNBV2GEBfR5db/AkGA8ICySJQr4PNJegnPM9DvwWDOkVRoIjPzs5C9pjEXgrrRhBS+LkgCAtkAb4KBoPgroYK08CyAcQTSevivoq6PYwGkGEJuQujgLlAIHD27FmRSJSZmYlTymAeOJCGfMGkAKIBE1zi9ATaKix4HA4HOI6iAiMoPAl+GwqFwJcMVPnESk+JDYCvYD0AP2RZNnFKQtMQTdNOpxNiQxfPRyBoC27E5/PB9AdJG8VisUKhcDqd0DDklQrzFEVR8/Pz0IYFkg7TLnwFSxq8UfaDBSvuSwxUIq6mpgY83hIToqPDFtRiXHCGL/zkC9uw+Hj4ZLHWu/jzxb9dfEL0z8SvFp8cBctC+g5IILDgDIsvt/g8WFnH3JV7C0vi32Ap37BhA2jwd9WGP086Pu+wBXr/5zXprie862gA2gmUMd6yZYtcLk+s+YLBPCg+b0JZ3OEXTyWLx3zEvaePxef8vIsm/vMeJ7zrJRKlj+M4iB2HZJGJAr74/Pc5LWJ+gGDFfekBAZ2rV6+GAmw/cIMZy7KZmZkcxyGfRQzmuwcU91WrVoFUEt/jPQSFQlFTUwPxeQ+6RRjMD8voZrVakSv/g24RZqmCFfelByzWDQYDtpYhJ0JUShaDeVAsCankeR7S0kF+d6w9YDDfGRCUhWcrzNcEK+5LEoiHe9Ct+L6wzOJOMEuUpSKVqD4D1toxmO8YPFthvj7YtReDwWB+WHxvnXkwGAwGc2+w4o7BYDA/LLCtHYPBYJYoWHHHYDAYDAaDwWCWAFhxx2AwGAwGg8FglgBYccdgMBgMBoPBYJYAWHHHYDAYDAaDwWCWAFhxx2AwGAwGg8FglgBYccdgMBgMBoPBYJYAWHHHYDAYDAaDwWCWAFhxx2AwGAwGg8FglgBYccdgMBgMBoPBYJYAWHHHYDAYDAaDwWCWAFhxx2AwGAwGg8FglgBYccdgMBgMBoPBYJYAy01xFwSBJEme5x90QzCYpYcgCDzPkyT5hYcRBEGSJPyBwWC+wjyFROkewHSGBQ2D+Qrw8els+YnPclPcY7dEUUKcB90QDGaJAVJDUfc1LOAVMgbz1bif5TEAwoinMwzmyyLEuc/pbGmxDG+JpmmO4x50KzCYpWpxp2n6CxUFiqJIkuQ47j71DwwGAyDB+UKVQhAEmqaxxR2D+WpwHEfTNLHsWG6KuyAIDMNgxR2D+bKgTfn7UdxB7WBZFivuGMyXgiRJlmVh6XvvI5Ew3r+FHoPBIDiOYxhm+a17l5vijvYWsUqBwdw/MLRFo1Gapu9TcGCFjL1lMJgvBc/zoE/cz8EkSdI0HY1GscMMBvNll8fEfXt+Li2W4S0RBCEWi8Ph8HJ1b8JgviUHM5ZlxWLxff6EYRiSJMPhMJYyDOY+oSgqHA6TJHmfijtMZyzLLtdNfwzmWwp0DIfD9z+dLS3ud+xYWojF4kgceG3Y9I7B3APYi49EIhRF3efGIqTFgBWySCQC3R0LGgbzeYBYsSwbjUYlEsl9JrsA50+KokA8sZRhMPc5nQmCgBX3pQRJklKpNBAIcBwnk8nwSIfB3AOO44LBIM/zSqXy/rfjYVhkWdbn88lkMrFYjAUNg7kHkUgkGAyKRCKxWPylBE0mk/l8PpjO7t9Uj8H8ABEEIRgMRqNRuVy+LHNBLlvFHawUEokkGo36fL4H3RwMZmmsdWGH8Uv9EFSQcDgcCoWw4o7B3HuTimGYr2AFpChKKpVGIpFAIPDttA6DWVZIJJJlGZa6nBV3QCqVgg/ucn15GMw3Ak3TEolEJBJ9WUmBFTJN02DhwIKGwdwDhmFgB/grCBrsaIXDYZwzDYO5ByRJSuIs4/mI7OnpedBtwGAwGAwGg8FgMD9gizuO48Fg7pOvaZzAgobB3A9Y0DCY7wBh+Zrbl7/ivrxfHgbzPQELGgbzHYAFDYPB4ATMGAwGg8FgMBjMEgAr7hgMBoPBYDAYzBIAK+4YDAaDwWAwGMwSACvuGAwGg8FgMBjMEgAr7hgMBoPBYDAYzBIAK+4YDAaDwWAwGMwSACvuGAwGg8FgMBjMEgAr7hgMBoPBYDAYzBIAK+4YDAaDwWAwGMwSACvuGAwGg8FgMBjMEgAr7hgMBoPBYDAYzBIAK+4YDAaDwWAwGMwSACvuGAwGg8FgMBjMEgAr7hgMBoPBYDAYzBIAK+4YDAaDwWAwGMwSACvuGAwGg8FgMBjMEuCHqLgLgnD/xyw4+H5+u+D4L/uTL2zS12nPdww07/MewuIPv/B2vsHn+YV8XvO+QrPv8/zfE77Bht37VJ/XK763TwaDwWAwmAfLslXcEzVvPgGSJCnqi++aoigyzoKD4fP7bwYVh/gmboSm6c9r5/38/IEAbf68h7Dgwy98NYIg0HGI74QFF0LNg/8m6pdfrUnfVMf4ZrlPAbnPBtz7VJ/XpRmGuZ8GYDAYDAbzQ2PZTpA0TfM8D3oA0g8EQWBZ9n4070S9P/F4UP3vvxlf9vgFwOIBGsNx3OJTfeH5KYp6gLo7tBlexBc2HlThe9wOTdMcxwmC8DVV3vtkwQNHzUtc/t3j1XzbfeNberNf+Ba+VAPufY+Lnxv09mg0+t28YgwGg8FglhbLc3YEzQO0CoqixGKxRCIRxwmFQi6X6wt38J1OZzgcDgQCHo8nUbdwOp3BYPA+dSaKorxxvo4WAldnWXZ2dnbBRUmShPbcQzf6Oqrh1wGe/+zsLMuyXq/X7/cnPjSSJFmWdTqdSHUjSTIYDDqdTvTiFp+QIIjJyUmPx0PT9Le6GqEoKhKJzM7OoqdHUVQwGPR4PNFoFDUbiEajDofjS6nRoP27XK5IJPKVXxBcnfjmgBURvIWv3wCSJDmOczqdd10qo2+j0WjityRJut3u6elp7C2DwWAwGMwPQnGnaZokyaGhIXCrGB0dfffdd996663f/e53ly9f9nq97e3tyFAKFlz4G/4Aj5pLly7Z7faZmZmenh6w08NioLOzc2ZmRiQS8TzPcRzYkhHgloNOS1HU0NDQ8PAwmP/hczgSfosuCtddcEKSJL1e78zMDE3TDofj3Llz8C2ch+M4hmHu3LkDWmPijcDfoFNOTEzARRMblthm+BDOLAgCOibx7wX3mHgManDir0BX8/l8dXV1wWBwcHBwdHRULBajloOC2N7e7vV64ScURc3MzNy5c0ckEn3epQcHB+vq6pxOJ8Mwd2124tNbcBJ0+4tf2YLP4Scej6e1tRWtmgRBsNvt/f39Lpfr/PnzwWAQXg3DMHa7/fLly4t7FDrz4k/gyDt37szPzzMMg25zQUsWdInELsRx3PT0dCAQ+LxXg3ry4luGr1iWXXxmkUg0Ozvb0dGReDt3bQDLsqgBi98XXNrv97e3tycudFH3oCgqFAqdP39+bm4ONlJQnzl58uTQ0NDinpl4L4tf2V1vE4PBYDCYZcYydJXheb6jo6Onp8fv9xcUFExOTra1taWlpbndbovF4vf77XY7z/MMw0ilUpIkw+Ewz/NyuTwajfI8L5PJwuGwXC6XSqWTk5MzMzMqlSoajUYiEUEQJicntVotRVEikUgqlbIsG4lE0KUZhoFlAyimJEnOzc2BYVIkEkkkEo7j4Hi5XA4e23B1giCkUinDMJFIhGVZ0FTEYjFYH202G0VRGo0GTL/Q7FAoRFHU5OSkXq+naVomk4EqJpfLwWAMXgrd3d0ZGRnRaBQawPN8OBxOtHzL5XKapiORSDQahfZTFMWyLMdxMpmMIAg4VeI9isViQRDC4TA4r0ejUYIgoAEkSYrFYtALCYJQq9UikWh6elqpVNI0LYkDenA0Gh0fH6+oqNBoNLAp4fV67XY7eO3L5XJ4NcjZRqFQDA8PC4Kg0+lYlpXJZCKRCN4LnBlWL9AYWL/J5XKCIOAJSyQSkiRpmo5Go9A2gKIomUwGTww+l0qlCoVienp6fHwcjpHJZAqFIhAI2O327OxshUIhlUrtdrvT6czLy6NpWqvV8jwPbwE1G3UGeIbwuqFJ0NMmJiZSUlJAqYXDZDJZYh+QSCQikQj6GPQHeLZgpx8YGCguLoZNJNjSSWwAz/NisRj8xFCvQ0Bni8aBC8F14S1MTk5C35DJZOiJoQbAQ2YYpr+/v6ysTCQSRSIRhUJBkmQkEgH1XSQSKRQKv98/Pj5eUlKCdpxQ54GuolKpmDjwaiiKmpqastvta9asARmBq0ciEdQz4eroQYHBHvXhxDeLwWAwGMzyY7kp7mBmvnnz5szMzNzcnM1mIwiioqLi4MGDTqdTrVb39vaCDicIQjAYRA7ToVAIlCf4Y9u2bVKpdGJiQiwW+/3+aDQKSphIJAKPedBmFngLsHESPeNBKYHjQclAV0HOCfDbcDgMl048ocPhGB0dDQaDZrN5165doMJCs+EAaA9So+HMcHWapn0+3/DwcCAQEIlEHMf5fL4F5xcEAR0P7itI9SFJEuypC/x8OI7z+/3wORwMJwyHw/CH3++Hs6lUqoceeohhGBRuCJoWQRBisRhU/Gg06vP54PHSNC0Wi6FV6NXAOUGx9ng8FRUVZrM5HA6jK8IzgU8SXYPA4ovaD5orutPEJ5DYDeC0YN+FxiQ+UpIkDQbDrl27JBKJ3W6fn5+PRCJJSUkpKSnQDPTEFj/MxCZBrwDFOvHZLugDkUgE3SN0bFDZYb03NDSUlJSk1+sTbznxlcGjXnzLn3chUM1pmhaJRImP4q4NCIVCQ0NDqampWq2WIIjEZwhHwmuFF33XziOXy3fs2AEuUtB4qVTqcDhsNltJSYnX60187GCSRw9zQfsTj7zvoQKDwWAwmKXHclPcBUFgGMZisQwODubm5iqVSrC2KpXKaDQqlUpB5WUYJhAInD592ufzbd26NTk5+eTJk2vXrtVqtefPny8uLnY4HKmpqRKJJBgMfvDBB8FgcM+ePQaDAa5CUVRPT8/169ezs7O3bdsGVkaxWNzV1TU1NeXxeJxO5+7du1NSUuByYrG4oaGhvr4+JSVl27ZtkUjkxo0bYrF4dHR027ZtcNj169c7OzvXrVtXVlYWDofFYvHMzExra6vdbr9w4UJVVVVLS8v69eu9Xu/p06e9Xu+mTZtKS0vBFs7z/OnTpysqKqxW68mTJ2dmZjZt2pSbm3vjxg273X706NF9+/YNDw9fuHDBbDbv3LlTqVSCu0IkEjl9+vTExMSGDRtWrlzZ29vb19cXCATy8vIyMzM//vhjkiR37NhhMBjAQUIikfT39587d06hUOzevdvtdo+NjVVXV1MUdfbs2aqqKp/Pd+rUKY1Gs3v3brFY3NTUVFFRAUZlkUjU2NjY2tqanp4OixCRSNTQ0GC321esWFFdXQ3PiqZpr9dbV1cXCoV2795tsVhCoZBcLr99+/bQ0JDdblcqlaWlpZ9++ml/f/+KFSvWrVs3NjbW3d3tdrtNJlNNTQ3YgycmJk6dOiUWi3fv3q1SqRobG8GWXFVVVVRUBF49sDFy6tQph8NRW1tbWFgYjUavXr06NDSUk5MDTiwcx50+fXpubs5sNkskErfb3dfXl5SU1NbW5na7r169mpGR0dXVtWXLlomJifPnz4fD4R07dmRkZLS1tU1MTHi9XoIgtmzZotVqx8bG6urqeJ7fs2cP6LsI0E0vXrw4MDAAfYDjuNbW1tu3b+fk5GzevFksFt+5c+fixYsmk2nfvn1NTU1jY2OnTp06ePBgSkoKdJipqanz589Ho9Hdu3ebTKbW1laHwzE1NZWamrpu3brEEO3z58/39vauXbt21apVgiDcvHmzra2ttLR08+bNKORAEIRz586NjY2tX7++sLCQpummpqYbN25kZmbu2LGjoaFhfHz85MmThw8fNhgMH3/8sdvt3rp1a1paGk3TjXGSk5MTHYHAb62urk4kEu3du1cul7e0tBQUFExMTExPTw8PD69Zs6a5udnhcJw/f76qqurs2bMjIyOVlZXr1q0bHBwcGBiYm5tLT0+vqqo6d+7c0NDQxo0by8rKwCML/llaWvrVAoUxGAwGg1kSLEMfd4IgFApFSkqKXq9HvubgpJEY1NjR0TE9PR2NRhsbGwmCmJ2dHRoacrvd4Bzf19fndDppmp6cnIRwvYaGBhTt6vF4mpubGYbp7e2F4+EqPp/v5s2bEMXY1tYG2iHDMDMzM7dv36ZpemRkZGxsjCCI1tbW2dlZn8/X0tIilUqHh4e7urpIkmxqapqbmwMfemi2SCSSy+U+n6+rqwuUubm5OY7jbt686fF44Jienh673a5QKLq7u8fGxuA8oVAIfq5QKEKhUFdXl0KhGB8fv3PnDvjci0Si5ubmkZERiqKam5sDgUA4HG5qavL5fAzDNDU1OZ1Ov9/f0tKCUjHCDUaj0bm5uZ6eHpIk4b+BQGBkZMTn8129epXn+enp6c7OTo7jOjo6wEYLXj23b9+WSqWDg4Pj4+MMw/h8vqmpKWitw+GAuyZJsrW11ePxeL3e5uZmWGCA3g+GapFI1N/f39PTI5PJ2traHA5HNBqtr693Op0SiQQ591+5ciUSibhcrvb2doIg+vv7x8fHOY5rb28PBALonLByEAShqakpGo1OTU11dXUxDNPd3Q26Znd399DQEEVRo6OjYNLu6ekBPyKJRCKTyTweT09PD0VR8OiCweCtW7dYlvX7/Y2NjdFodGRkZHBwkGGYq1evhkIhr9fb2dmZmG4FWtLT09Pf388wzM2bN11xWlpaJBIJrKZYlu3o6EBvEDyFwJUFbpnjuKamJn8caMDk5CTcRU9Pj8PhYBgGXvro6OjExIRcLm9sbHQ4HHNzc21tbbAwmJmZgSdDUdRAHNDCg8Hg7OxsU1OTWCzu7+/v7u5GDYBAC7vdznEcyMjc3FxTUxNJktPT0yBE0EKWZa9cucJx3Pz8fHd3dyQS6enpCQaDdru9ra0Ngshhl0MkEnV0dPT394tEora2tmCc+vp6r9erUCgGBgaGhoag24A3ztTUlFKpvHHjhsvlSlwqYDAYDAazzFiGijuY2AsKCrRabTgcZhjG6XR2d3f39fXNz8+DW3YwGOzt7V29evW+ffvsdrvX662oqOjv7+/s7ExKSjKbzeDdAb4NGzdurK2t7enpAb8FiqImJiZCodDTTz+dkpICejCoX+DAvXbt2g0bNgwMDEAqFdB39Xr9008/bbPZBgcHwb8lPz9/8+bN4Lfd2dlpNBqffvrpaDQ6OjoK59Hr9bm5uRkZGWvWrGFZFtyse3p6qqqqdu/e7ff7XS6XWCz2+XxtbW1lZWVGo7G9vb2kpOSRRx6Zm5ubnZ1duXKlTqfbtm1bOByempp6+OGH169fHwgEUKJMr9e7Zs2aJ554wuPxzM/Py+VyhmHWr1+fnJzc0dGxdevWbdu29ff3Q3whPDeRSHTo0KG1a9f29fWZzWbwOZ6bm1OpVOBo8dhjj1VWVvb19YHrOfJ18Xq9SUlJzz77rMlkgoBdj8eTkpJy6NAhlmVHRkZEIhE4TvT29tbU1OzatQuWUiKRKBwOFxYWJicnr1q1qrCw8Pbt22az+bHHHqNpGp4nx3GrVq2qqKgARR98sg8ePFhTU9Pf3w9aY2Zm5q5du9xuNwoJhWjIDRs2HD58eHZ21uv1joyMqNXqQ4cOwTlBK7XZbA8//DC4lNA0zTCM0WjMy8uz2WyrVq0CpyCv1wvG8h07dgwODrpcLniYGzduzMnJGRwcBPeb/fv319bWDg8PQ19KDDZoa2tLT08/dOgQJC8aHx8XBOHRRx+1Wq2dnZ1erxfe4IYNG7xeb3FxsdFoXLduncVigVZ5vV6wOm/btq2vrw8cljQazUMPPSSXy8fGxmBdJJFIBgcHlUrlM888YzabA4HAwMCAXC7/0Y9+BGsqlOayq6vLZrM9/vjjPp9vbm5ucHAwHA4fPnzYZrPZ7faSkhKj0VhTU2MwGBobGysrKw8ePDgxMQFLuFAo9Mgjj6SlpSWmAIIkjwcPHqyurh4YGGBZViqVwhpSJpPt2bMnJycnLy8vIyOjpqbG7XaXl5f/6Ec/gvQ+IBHr1q0rKirq6OjIysp64oknfD7fxMTEyMiIXq9/5plnNBoNcvfHYDAYDGZZstxcZcANpry83G63p6SkyOVyMNDa7fZQKLR582ar1QqmcUEQsrKydDqdXq+fmpoqKSm5du3a3Nzc5s2bQWkDe7nRaExPT09OTgZfC1ALZmZmUlJSTCZTbm5uU1NTouttZmZmRkaGSqVqbW0F+x+4Qe/Zs8doNJpMprGxsVAopNVq8/LyQJFyOp0+n6+kpCQ1NTUrK8vtdqM6OAzDiOKAEdTj8UgkkuzsbI1GU1NTA3sIXV1dgiCsWLHC4/GEw+Hs7Gyj0Wg2m2dmZvLy8lC0KM/zPp9v9erVfr+fZVlwU964cSOEdarVavBgTk1Nzc/Pt9vtYrE4NzcXtTAlJYVlWZVKtW/fPrVaHQqFWlpaIM+mM45EIjEYDAcPHlQqlU6nE1RV0NhAb05LS9u7d68qTiAQgL2InJyctLS0vLw8l8ulUCgYhpmfnxeLxeCnJJVKvV6vyWRC4YmwNvD5fKtWrYKFjdvt1uv1ycnJ2dnZkG0G7MoHDx5UqVSwUQBvMysrKy0tTa1WezweMN6Hw+EtW7aAA5VGowkEAi6XKycnx2KxlJWVgV08EokUFRWZzWabzQa+1KDxQ3vg1dA0PTc3p1Qq4dUbjUbw8E5LS8vIyHA6nY2NjSzLHjhwQKvVQuAvSlWOPHZCodCGDRssFsuWLVsUCkV/f39OTo7ZbC4rK7t9+zY48cMbBEd2kUgEHuTwJOfm5tRqdVpamkwmMxgMXq+X47i0OFarNdHyDZHNIpHooYceAnemnJwcrVabmZnpdDohuBmc1FevXq3X61NSUubn5z0eT25urtForKqqAj91aAB4n+fl5SUlJWm1WqfT6fV6s7KykpOTnU5nf38/+K7ArsLDDz+s0WhcLhcKEYbbt9lsFosFbgSCIlatWiWRSKC3gLtRWlpaVlYWJGktLi62xpmbm6MoKhwOwxuHzRbsKoPBYDCY5coyVNwFQVCr1RRFKRQKyEphNptLS0t9Pl9aWhoke+E4bmpq6vjx4wzD9PX1paSkVFVVpaSkOByOrKysxOzaOp2OYRjwtEE53aempoaHh1999dW5uTmUxgROq9VqZXEkEonP54MGiMXixsbG3t7e2dnZrKwslmUlEolCoWBZViQSud1unuevXr3a3d09MDAAntag68DlkPN3MBikaVqlUlEUlZmZCWltent7q6qq9Hr92NjY7OzsmTNnpFJpX1+fUqksKioCSyesT44cOVJSUrJhwwaapkF3j0Qi586dm5+fn5qaAuO9XC6XyWShUGh+fv6Pf/wjJD/xeDzp6emRSEQikfT19TU0NMASgiAIg8EwPz/vcrn0er1SqWxtbW1qanK73UqlcsF7kUgkly5dGhoacjgcxcXFHMcp40BWlunp6UgkIhKJ5ubmpqenP/roI3BY2rBhQ+KbBR2X4zij0SgIgsFgADcSpVIpl8vBER/0v9HR0Vu3bqFXJhaLpf8Berywejlz5ozb7YY0+eFw2GAwCIJgMpnA/M/zPFxLr9fPzMwk2shRuSJYUykUCrFYLJPJ5HK52+2GG5RKpUqlkuM4mqZnZmaOHTvm9XoXVBKgKMrtdsPyief5jIwMjuO8Xm9ubi5cF7yejEYjvMGamhqUVzTxDEqlUiwWwxuEEyoUCpFIpFKpZmZm4MhwOJyRkdHZ2fnmm2+CM/38/PzExMTw8LDdbjcYDBBxATn4L1261NDQAH4pDMMkJyeTJGk0GrVaLTQA1gCBQODYsWMSiWR4eNjhcASDQYPBAB1VoVCAU5AgCOAS9sknn3g8HghIRbGzKpUKJCXxXdfV1c3NzUHOzVAoBGez2+3T09OXL19ubm7u6upSq9W5ubktLS1vvvlmTU1NZmYmTiyDwWAwmGXMMtxWhmRzEH8pCEIkEklPT3/ooYe2b9+ek5ODlDaKosCeWlhYaLFYWJYFK+yCSjrIXgtOOOhzSEStVCpXrlyZqEXByeH88CuRSDQxMXHjxg1wrUbFUFHmadBsSJL0+/2pqanZ2dlI+UBKD7o1lE5bKpUidw6fz4esyKCc5eXlpaWlgROFIAgqlWrNmjVSqbSxsfHOnTvIZ72pqam3txc1G6XvAA97nuej0eiKFSs0Gg0k+YZwTKfTCZ4zPM9bLBa73R4Oh/V6vc/nu3LlCnhHLHgpDMOMjIzcvn07EolANhVoAMoEj2zzkKkTbNLl5eWQ/BH5P6DjITNgYoJw9NBAuYf9E+TFBGuVxfouxLyiSqjwAFGAY2KmcJTbMfHVJPY6lE0fngxKWw4PMxAIXL9+fXZ2FpxtEpuBXjHcBexjJNZk5XleqVSiN9jR0ZF43cUNgPeI8qMn3i/syVRUVMzPz1+8eHF6ehrM9sFg0GKxFBYWopYj27zNZsvMzIQtAsikBMlMUW+E9iNDOLyvBTVuwVfq2rVrkIZ/wRNIfH3wslpaWjo7O1GvgIeQeM5gMAjbNTabrbS0dHZ29sKFC7Bc+fyxAYPBYDCYpc0ytLgj4zfKj8HzfCgOUm1JkkxJSTlw4AD4xUK9RrvdHggExsbGwNIJpwKTLezsK5VK+NxisWi12j179ni9XtAn0GnBEYVlWcg2DRr28PCwXC7/6U9/euvWLXC5RuoIWCIpitqxY0dpaanH40m06aI1BvKhh9SHYEOFVIBFRUWTk5P9/f2ZmZlms3nv3r1Wq9Xv99M0DYVIQZFNS0t76aWXjh8/3tPTA6m1eZ4fGRnZtGnTunXrfvvb38I+AyT7E4lERqPxhRdeAN0dMl3KZDKHw+H3+19++WWPx3Ps2DGCIKxWa3t7u9ls1ul009PTHMe98sor09PT586dS9QpaZru7+83m82vvPLKqVOnYA0D4bAQ2wphjizLarVacHxXKBSQjhBp2/A0IO26x+NJTU31er2Q8T0xESSYn30+3/PPPx+NRo8cOYL8WxLjQeG1jo6O7tixY8WKFb/97W8hBSTE5rrdbrgWQRBer9dqtXo8nsSMJYkLKkgzDykROY4D8/Dc3BxqFZjbXS7Xc889F4lEjh8/nthdwckbUnNC2nsIe/V6vSKRyO/3g0NOSkoKeoO5ubkoeAA1AByQotEo9BAI/F3gNwJ3XVNTU1hY+Ic//GF0dNRgMJSXl69evdrn88lkspaWFviJ0WjcvHmzzWbz+XwqlWp0dNTtdtM07Xa7YacI9UmFQvHUU08plcpAIKBSqTo7O0GBhqSN0NNQnPdLL700Pz9fV1e3WGYT88/09PSsWrVq3759//7v/452wOCNWK3WDRs25ObmgsMbJIYqKSl57733ZmdnYTcAe8tgMBgMZlmy/K1TYBtGGgz8FxKtzMzMyGSyS5cuORwOyLNRVFTU39+Pyq+C73IgEJicnHS73Wq1GvRgtVo9NjbGMMzY2Njly5dBrwJ38OHhYXccj8cDng/gkQL+M1NTU6DxgCUYWiWVSuGHkOijo6MDGVwZhkGBoWA49/v9s7Oz0Wj09OnTYLwsKCjIyclpaWkBK+b4+LhCobh+/frQ0BB4j0SjUXB70Gg0YIZH1lzwI/L7/TMzM5DQAy4kk8l8Ph94KdTV1blcLpQanKIonU4HlZLAWcXlcoVCIb1eHwgExGKxwWCAiFt4gOgVBINBcB2Znp4Gs3o4HJ6eng6Hw4ODgyqVCjYQtFotPECCIM6ePQv3iPL5wPMXi8UQ/Do8PAye8Yl2VtBNKYoym81jY2OQJD4xJTzS6qDipsVicblcs7OzCoVCIpFAVGhvby+YxkmSHBwcJAhibGwMbOdwLYlEAnWOoHk6nc7lckEc59TUlEqlSty9gT5AEITJZJqenvb5fBCJi5KUKxQKSORC03RdXd3U1JRerx8dHSVJsre3VywWu1yuixcvajSa1NRUqJQESzh46RzH6XS6+fn5YDAI7iXgLYb6PNLvpVJpQ0NDV1dXdna2TqeLRCIqlQqef3d3d2NjIzxMsVgMmyQqlerWrVvd3d06na6vr4+iqI6Ojlu3bsHLCofDCoUC1j8KheLixYt2u12lUg0NDUUikZmZGa/XC88Hco+SJGkymUCDBxGDtiUuh6Cp4LPk9/vRVhJY8WEpZbfbpVLp9evXh4eHW1pa+vr68vLyVCoVKiaAwWAwGMyyZHla3BHIBxe5gkSjUY/Ho1Qq09LSTp8+DRnxysvL6+vrMzMzs7KyPvjggxUrVkCpoGg0GgwGT548OT8/n5qaKpfLvV4vRKBeuHDht7/9LfjEJ6odPM/X1dU5HA6wyoNRMCMjo6mp6a233urr68vIyGBZFuLtwJoLsX0XLlz49a9/PT4+vnnzZqRYg+p59epVCPVTqVTp6ekXLlyAspRqtdrtdpMkuXLlyjfeeGN0dDQnJ+fy5csDAwN2u91ms8nlcp7nz5w5U1VV1d/f//rrr/t8voyMDKiaCeGkdXV1Wq12fn4eFEHIOQP5ND/88EOtVutyudavXw/ODDqdjiCId955x+FwgNYL9u9oNKrRaNxudygUevPNN+12O9hHvV4vVDgSi8Xp6emffvrp66+/PjQ0VFhYCAVZ29vbx8fHvV5vZmamw+Hwer1qtdpsNh87dgwWD2vXrkWGWKiExXFcUVHRlStX3n777ZmZmZqaGsgdiV46rHAIgnjrrbdcLpff7we7LLh5BAIBUHwh9b5Opztx4oRSqYQnYLPZTp48+d57701OTsL+RkFBwa1bt1wul8PhkMvl8O54njcYDCdPnrx16xY4lOt0OovFcubMGZ7nTSaTXq/v6uoKBALgouN2u41GI0VRb7/9tsvlCgQCkC8SRVJSFFVQUNDU1DQzM2O322tqajIyMlpaWt56663x8fH169dDjDV6gxKJRKPRnDt3zmw26/V6eDUmk+nkyZORSMRqtWo0GohDAMs3iAB6ROfPn4foYYvFwvN8Y2Pjq6++Ojo6unnzZrhBmqZzc3OvXr06MzMzMjICsb9NTU3vvvvuxMRERUWFVCpVq9Vnz561Wq1FRUWnT5/u6OgYHx9fuXJlZmbm7du33333XXhQcI8syxqNRo7j3nzzzenp6VAoBMWYOI5DSjzk7YHI19TU1GvXrg0MDExNTUHsAewniESijIyM27dvj42NjY+PHzx4UBCE06dPw0LOYDAscGHCYDAYDGY5scwt7jzPa7Vak8kE/tCgkppMJpqmy8vLwaYIie0YhsnOzjYYDElJSeFwOCkpSSaTqVSqoqIip9MZDoerqqrAiAtZO4qLi0dGRsRicWVlJXLPjUajKSkpfr8/GAxWVFQwDGMwGFQqVXJystFoHB4eTk5ONpvNIpEoOTkZ9NHU1FSCIMBbt7+/Pz09HTniQwhmcnLy1NSUVCq1Wq0ikaiiogIia1evXg23RlGUxWLJyckJBAJlZWUqlWpgYAB83OHM8/PzKpWqsLBwYGAA3N9BbSVJMi8vD5K1l5SUMAyjVCotFgtE01ZVVUEu8JUrV2q1Wp7nIUOlzWYbGhrSarVpaWmgIRUVFaWnp4MlPiUlpb+/PykpKT09HfyRaJo2Go2w5FAqlcPDwxkZGVarlSCI/Px88MGAMAOxWGy1WkmSrKys5DgOLq3RaFD6EYvFolKpICwhKSlpYGDAZrOlpKRIpdKkpKTEl65WqzMzM/v7+/V6fVZWFkEQycnJEokE7OsqlQrcb2iazsvLczgckUikuLiYJMmMjIzk5OShoSE4M8uyZWVlOp1ueHg4Nzc3OTlZJBIlJSWRJKnX641G48zMDFydpukVK1ZAjs7Vq1eLxWKlUmkymcBjymq1arXarKysgYEBpVJZWFgIbw1WVrDyKS4u1uv1g4OD5eXlFovFbDZDHkmLxVJQUKBWqwsLCyEnY25uLkVRubm5oGRD3lKJRLJixQrY6oEGGAwGjUYTjUYTRSAajRYUFGg0ms7OTqvVajabk5OTc3Nz+/v7dTpdYWEhtFYQhIKCApPJ1NfXZ7PZ0tLSLBZLcXHx4OCgXq8vKyuDzhMOh71eb1VVlVwuHxwcLCkpMRgMVqsVpEOhUBQXF4NBHWJ8MzIy+vr69Hp9Xl4eTdNJSUnQTuhgsOKCBJfFxcWhUMjpdObk5EilUoVCYbFY4OUWFhbCg8rNzU1NTc3JyVEoFJ2dnSkpKQaDAQenYjAYDGYZEyugQyxrQCFA7hbwT3DhCIfDKJk0ZFkB0yCqQQO+0dFolOd5uVyOggUh7C8YDDIMA8kEwb3k2rVr8/PzO3fuBN9rFMwHfgLhcFgmk6FNf3BySLxuMBgEV+/E9oOLBYpDhXBbcJ2HZkN7wDkELgSeOXCP4A8jlUrB95phmMQq9DzPg70TkhvCjaDQUnDahgshszfHcYFAAPzy0SXAqwfaBsln4FsI+YWHBqZfaAxS5sDMD3cNoYeghsKOh0KhSLSeovPAGgkWGJCeHFySEp8bPE+pVAoZUdBzTjxJ4hMQiUTQKvARR7cAmzbQT8A0jq6V+GqgGeA8A273ibcDB8AGDtw+nCfRSwRuKhwOQ8+B+w2FQnCP6J/oDYIxG14c/By85AVBWNxXE18rtBwuBB+yLAteN+CjhW4QPQpw7GFZFrzwwasKGgBFCdAjSuzM8AwT7xF1cngFKAY60ZkHPTTIPAMnWdAzoWFSqTSx16HbwWAwGAxmubL8FXfQOVC9G8hoEQ6HoeYoKBmg6YLWJZPJIBkL6KPwc9B1OI6DQjBIR4FNfNA25HL5uXPnnE7n888/7/F44DBQcUBbRVGz8HkoFCIIQiqVQggmqJigeyW2XyaTgYYEP0HNhrTrkBESIkchawpcCJRIFPkK+hZoOdBgVLATHPThBkHPg2cFSdPRhZDulahIQXJx0PbgV/AtnB80eOSHDbZnlGsFHgJS10AlhcR/oJuCnpeYIhAS0oNJFe4L6bLwThOfG2R8h1sLh8NisRjcbMABBiUXQk8AOgl4gYNaDD+EIATUbFDBQWWH5RBEakIz4FHAogJWAuFwGFYFkNIRrY7gAHh3yBMd3iy8O3iwUJ8IugT6eTgchmZIJBLQmFHfhucWiUQg5SjSraElyC0HUnne9UKwioPP0aOAviSRSKALhUIhSJYvkUjQ6g6WChBBseBOUXKexM4DDYMIBJRVBtYhqA+AZg8tR61a8KDQ7cDVv5NBBYPBYDCYB8PyV9xR9kD4Z2KuRvgKmcDBNIiSDC5ICIiMxCigMPFzUFY6Ozs9Hs+aNWuQ225i7kLkZw+fI3N1ot0axa0i4IfoJ/duNmrwAhMmqGWJIZ7o4UCTEnPXoD8WnAq1B/2NWr7gcuhbuLvEhwBfocYnngrZej/v0ujhL3hciUbixIMXtGTBG7zrE0h8s4knR81e8O7u8Wrgb7h9OCCxSaiPJSa6QReC86PjF/wzcb8iMUnlXRuQ+MfnXWjBw0R9YEGf/LwGfF6vSxSQxZ0HWdzROReL57175oIXtKC3YDAYDAaz/Fj+ivt3Buh8kGbkQbcFg8FgMBgMBrPcwAaqbwwwbIOvAgaDwWAwGAwG882CFfdvksRqQRgMBoPBYDAYzDcIVty/YXAOaQwGg8FgMBjMtwFW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUAVtwxGAwGg8FgMJglAFbcMRgMBoPBYDCYJQBW3DEYDAaDwWAwmCUA86Ab8D1CEAT4gyTJBZ8kfojBYDAYDAaDwXz3YMX9PyFJUhCERAUdK+sYDAaDwWAwmO8Jy1xx5+PQcQRBYFmWIAiaphcfRtO0VCplGIZl2XA4zHGcIAhisVgikZAkGYlEQqEQRWHPIgwGg8FgMBjMg2E5K+48z0ulUrFY7I8jEolUKhVJkn6/f4E/jEQi8fv9/f39Ho9HrVanpKTIZDKapmdnZ+12O8dxFoslLS0tEokkOs9gMBgMBoPBYDDfGctZcReJRIFAYGJiYnJycm5uTi6XJycnWywWqVQqxIHDaJoOhUK3b9+ur6+32+1Wq/Whhx6qqKiw2+1Xrlxpa2sLh8PFxcVbt25NTk7GijsGg8FgMBgM5oGwnBV3giBu3bp17Ngxr9cLCrdYLF6/fv3BgwcZhgF3drDKNzQ0vPPOO6FQiCAIh8ORn59fVlZ2/PjxCxcuiEQiQRBmZma8///27u0nirOPA/icdnb2CBiQk4CiKIKQKiiWarA12DdqqrXn6970tv9J75o0aZr0lDSapk2aisQGErQoFbSoIGxZOQgssOdlZ2fn8Myb8ks3BK3lbd36At/P1brMPPvs4MV3Hn7ze1KpDz74gOrgn/fXAgAAAIAtZxMGdwrWDoejp6fnhx9+mJqaYoxJkmSt6OnpkWX53LlzdKQkSbFYrKenZ2FhweVymaYZjUZLSkrGxsb6+vpUVVUUJZvNplKpEydOiKJoWdbz/n4AAAAAsBVtzqctJUmam5v7/vvvg8Ggz+dzOp0cxzmdzqKiomg0evny5bGxMafTyRhzOBzz8/PDw8MFBQUOh6OioqKxsbGuru7evXuxWKyoqMjpdNbW1u7atautrU0URcYYldmsLrYhq99cc0Dun3T6c7oqAAAAALCBbcIVd3rqtLe3d2pqyu/3G4YhSRJVvBiGoShKMpns7u4+cODA7zcugpBKpZaXl/1+v8vlOn36dEFBgcvlCoVCiqJomlZfX3/y5MmFhYXt27czxvg/rOnyvqZ3JB2zujH8E3vDAwAAAABs0eBu27bD4VhcXOzr65NlmVa4z549W15efu/evYGBAcrNgUAgGAxWV1fLsqyqKsdxlmXt3r377Nmz1PlxYWGBOkieOnWqo6MjGo06HA7DMERRdLlclPjpSErkPM87nU5BEAzD0HXd4/HQM6+GYVAZvaIopmk6HA5d19PpNDpLAgAAAMCWDu6UoScnJ5eWlrxer6qqJ0+e7OzsLCgoqKmpMQzj2rVrHo8nGo2Ojo42NDT09/ffvn2b+swYhjEwMOD3+0tLSxcXFymRRyKRvr6+6urq0tJS27aTyeTt27dnZma8Xu+uXbtqa2up6l3X9fHx8UwmU1ZWVlJS0t/fPzY21traWl9fzxibnJycmJiIxWKKolRVVTU3N1PBPTZ4AgAAAICtG9xt2w4EArRA7vP5XnvttZKSkkwms2/fvs7OzsHBQY7jstns9PS0JElXrlwZHh6mQprJycmPP/64vb39/Pnz6XSaUnV3d3cqlXrzzTcvXLgQCoV6e3sHBgZGR0cLCgoOHjx44cKFqqoqy7KWl5e7urrm5+c7Ojqqq6svXbp07dq1Dz/88IUXXggGg11dXTdv3gyHw7IsNzc3cxzX0NDwvK8TAAAAAGwkm61gg9J2IBCgfVLr6upKSkosyxIEIZPJ7Nmzp6mpSVVVURSXlpaSyaSqqlTuwvO8YRixWCyTyeTG4Xk+lUpFo1Fd1yVJGhoa+uabb+bm5txut2VZN27cuHz5smmaVBUzMTERCATGx8e//fbb6enpwsJCh8NhWVZXV1dPT4+u616vV5blsbGxzz77TNf1xzdwBQAAAADYQsHdNM1IJEI92vft2ydJkmmatMpeUFBQWVlpmqYkSaqqptPp5eVlXdcppmuaFo1GqeQ9V4OeSCQikYiu65FIpKurK5PJqKqaSCRUVbUs65dffhkZGZEkiTGm67ogCOPj48Fg0DAMTdNs247H4/39/bquL/8hlUp5vV4qoH/eVwsAAAAANoxNWCqjaZppmhTct2/fnls7JxSaqSpd07SmpqZ4PE5hvby8vK6ubteuXbmGMLZtNzU1pdPpmpqamzdvBgIBr9fr8/laW1sXFxfn5+cTicSdO3cOHz5MneNdLlcymdR1vaKioqSkpLi4eGZmJh6PK4pSU1NTVVUVjUbHxsaOHz/udDpzNwwAAAAAAFsruNu2TSUx1LfRtm2Xy5VbO6co7/P5FEWxLMswDFVVz58/H4vFrl+/LklSU1PTqVOnFEXJBXfG2BtvvOHxeMrKyj766CNK24cPH37//fd7e3s/+eQTnudnZ2fpeMaYZVmSJLnd7vb29qqqqvr6+jt37siyvLy83NbW9vbbb4dCoa+//rq2thZdZQAAAABg6wZ3SufZbJaCO226tPpHlmVRobmqqtS3sbi4uKioiDHGcZzf79+5c6dhGOl0OndWeXl5aWlpLBYLh8OMMb/ff+zYsbKysoMHD1ZXVz948CCRSFBjmdxtw7lz506fPi2KosfjSafT1KHy4cOHkUikurr63XffdblchmFguR0AAAAAtm5wp/L0XCbOZDJ/tk2SsIIxtmbx+/E8LQhCIpHIld/cvXt3aWkpHo9nMhlJkijor37StLm5uby8PJFICILgdrtN01QUZXR09NNPP927d29nZ6fL5UIrdwAAAADY0sGdymOodoXn+WQySavp9KPcpkgcx8kraIem3OlsxeoB6YBMJkO7L2Uyme+++87lcqmqmslkRFFUVTUej1NwtyzL5/N5vd50Ok19Y3bs2EGbLjHGent7h4aGVFXt7Ox0u93/+rUBAAAAgA1sUy36Ul5XFIV6tgiCkEwmKcHTAYIgpFIpXdcpuFP79tVL7PQA65oxRVHUdZ3qYSRJoq7ttB+qIAiWZWUyGTrLsiy/309bq4qiaFlWTU1NXV0dreu73W7G2MWLF/v7+yVps90yAQAAAEBebbb4aNu20+mUZZmC++TkJOVpyvTZbHZhYYHaQbpcLkrS6y+/oTErKytpvZzneerOvvoGQJKkXB8bxpjT6Tx//jzHcYODg7Isu91uVVUHBgY6OzvzfzEAAAAAYPPYbMGdQnZZWVkoFJIkaWJiIhwOV1ZWqqrqdrvj8fjExAStmhcWFvr9fiqbeTrbtmVZpmIYQRA6OjoqKyvT6bQkSYqiGIZRUFAQi8XIADXnAAAII0lEQVRyB68+17Ksl156ybKsbdu2BYPBUChUWFg4MzOTSqV8Pt86bxsAAAAAADZbcKfcXF9fPzQ05HA4IpHIjRs3Tp8+Tf0ff/3115mZGVmWNU2rqqpyOp3ZbPYvu7swxrxeryRJtm1bllVZWdnW1pbNZm3b1jRNlmVBEGjLpzUn0jtzc3OHDh1qbW29evXqF198kV0RiUT8fv+aQh0AAAAAgC1R4054nq+rq6OmMbZtd3d3X716dXFxcWBg4NKlS6Zp2rbt9/vr6+vXk9ppK9aSkhJZlmn71Z9//jkWi/n9/mQyefHixT/rD0N1NaqqXrx4MZFI+P3+o0eP1tTUUCPIXFk8AAAAAMBWXHGnZu3V1dW1tbXj4+M+n29hYaG7u/v+/fvRaPTRo0cejyeVStXX1+/evXude5fSc6h79+4NBoNut3toaMiyrNLS0rm5ueHh4cbGxiNHjjzxRFEUHz161N/fv7y83NjYyHFcLBajDpKFhYVYbgcAAACArRvcqazc6/WeOHFifHxcVVWXyzU7OxsMBh0Oh9vtXl5e9vl8x44d83g8mUyGnjp9YjOZ3Js8zxuG0d7ePjg4GIvFGGM//fSTIAimaYqi2N/f39bWRil8zTiCINy4cSMajfb29o6Pj9u2HQ6HOY4rKioqLi5GgTsAAAAAbOlSGSpTOXr06IEDB0zTpE4vHo+HurZzHHfkyJEXX3xR0zQK2WseJ30cBff9+/cfP36cMSaKotvtVhTF5/MJgjA7O0udIh+fA8dxMzMzgiB4PJ54PJ5IJGgOra2t1IgmbxcAAAAAADabTbjiTtUyfr//vffe83q9169ftyyLerF7PJ7/rFAUJZvNUm26pmlLS0v0Ti7KRyIRy7JoPyZqBClJ0iuvvBIKhW7dukVL9ZlMpqWl5a233rJtmzEWi8XC4TD1iqFxTNN8/fXXdV0fHBxUFIXn+Ww229jY+Oqrr+a2iHreVwsAAAAANoZNGNyJYRgNDQ22bW/bti2RSJimKctycXFxR0fHzp07VVXNZfQDBw688847kiQ1NDRYlmXbtsPhuHDhAu2ZqiiKZVmCIOi6XlFRcebMmR07dszPz9MWTi0tLUeOHMlms36//8yZM6lUatu2bW63m06xLKu1tVVV1bKyMtqx1ev1Hjp0qLq6mv4UAAAAAACwTvzY2Bi3STHGqFdjOBxWVbWoqKiwsDCbzZqmuboPjLzCtm1d16mtO8/ztMUSx3GqquZqWijTy7IcCoVM0ywrK6P+MNTBhjZSZYxlMpncKYwxl8tlGMb09LSmabW1tS6Xi055HpcEAAAAADaqzRzc6fFQCtNUm06r4GueCqX3KWTnqtUdDge9oPaRqwcURZEW5iVJyp3C87wk/f7nC+r1vvoUURSppyRjjIZ9Yk08AAAAAMBWLJUhlmXR+nouOtPr1ccYhkE5e/WPNE2jF7Rhao5pmoZhUBbPZrN0FuX1PzuFVvElSRJFkW4DsNwOAAAAAP+rTR7cqT+jveLxSE2eGKOfeOTqmP54/n76KbQM//htAwAAAADAemzy4E6eeVb+GwM+3ioeAAAAAGD9ULMBAAAAALABILgDAAAAAGwACO4AAAAAABsAgjsAAAAAwAaA4A4AAAAAsAEguAMAAAAAbAAI7gAAAAAAGwCCOwAAAADABoDgDgAAAACwASC4AwAAAABsAAjuAAAAAAAbAII7AAAAAMAGgOAOAAAAALABILgDAAAAAGwACO7PmL3i3/mgf+GU/6tv/ZSP+J8msPrgZzjzf+1XDwAAAFuTxG1GjLHVEUoQBJ7n8/qJtm3zPG/btiT9fkkty8r7b06S1nzNp+N5XhTFPE1MkiTbthljXN7wPC9Jkmma/3ACtm07HA6O40zTtG1bXEGv/8n0nuFQAAAAAFsouDudTlEU6TVjzDRNy7Lyl915nhcEgTEmCEI2m81Fw7zSNI2S4jpjomVZ2WxWluU8TYaCNZc3jDFN0xRFeeL3XecE6Delqqpt206nU5IkXdfT6bSiKP/kvwfdsD2ToQAAAAC2VqmMaZr6HwzDYIzlNUvRWi+lt5mZmWAwmNeP43nesqxAIJBIJNYZ3AVBiMfjv/32Wz4mJgjC7Ozs3NycIOTlvxMtZsdisZGRkSeuqfM8Pz09vbi4+PQJ0F9F0un0yMhIMBgUBME0zWAweP/+fcMw/smV4Xn+WQ0FAAAAsIWCuyAI/f39X3311eeff/7ll19evnw5kUg4nc58FHLYti0IgqZpyWSS53nG2MjISF9fX14X+Clx3rp1a3FxkUpE/nKSoiiGQqHh4eE8zWdiYuLhw4d5+sq2bcuyPDo62tfXt7y8LAjCmq/M83wgEJiamnp6cKdf0PDw8JUrVwKBgNvtDgQCP/744927d6kC5++VuDDGFEV5JkMBAAAAbK1SGUEQJicnJyYmSktLVVWdnp7mef7ll192Op3PPE5RVcyjR4+mpqZOnDghimJRURFlxGf7QY9/bjgcpvqQ9RzP87yqqrFYLE/zSSaT+asOor8wFBQUVFRU/NmNSjKZ/Ms6GVEUVVUdHh4uKyvbv38/YywYDJqm2dzc/M8n/wyHAgAAANgqK+4cxymKUl5efujQoX379kmS9ODBg1gs5nA48rEOKghCOBwOBAKMMVEU9+zZ09rauv7S879NUZRcHf96SJKUpwJ3juMcK/I0OM/zhmHs3r27paXF7XZTxcvjE3h6cKezDMNIpVLt7e0tLS2apum6vmfPnuPHj8uy/MRh1z+9ZzIUAAAAAPfn/gswL1VHPy8SxwAAAABJRU5ErkJggg==" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 172.66, + "y": 490.28, + "width": 65.27, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_4", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 4, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 73.44, + "y": 543.06, + "width": 211.72, + "height": 66.67, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_5", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 5, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 92.97, + "y": 654.17, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_6", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 6, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "typing", + "properties": { + "x": 92.97, + "y": 654.17, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0, + "text": "h" + } + } + }, + { + "id": "mission_01_7", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 7, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "typing", + "properties": { + "x": 92.97, + "y": 654.17, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0, + "text": "hy" + } + } + }, + { + "id": "mission_01_8", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 8, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 85.94, + "y": 704.17, + "width": 256.25, + "height": 77.78, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_9", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 9, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 316.41, + "y": 543.06, + "width": 211.72, + "height": 66.67, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_10", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 10, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 335.94, + "y": 693.06, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_11", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 11, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "typing", + "properties": { + "x": 335.94, + "y": 693.06, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0, + "text": "c" + } + } + }, + { + "id": "mission_01_12", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 12, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "typing", + "properties": { + "x": 335.94, + "y": 693.06, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0, + "text": "ch" + } + } + }, + { + "id": "mission_01_13", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 13, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"c\" has been entered in the destination field, and I'm currently in the process of entering \"Chennai\" as your arrival city for the one-way flight search. Since I need to complete typing the city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"ch\" next, I'm building toward the complete \"Chennai\" entry, which will help the system recognize and suggest the correct Chennai airport option (MAA - Chennai International Airport). This is a critical step in our flight search process because we need to accurately specify your destination location before we can move on to setting November 1st, 2025 as your travel date.\n\nWe're currently at the stage where we're completing the essential route information for your flight search. We've successfully set Hyderabad (HYD) as your departure airport, and now finishing the destination entry is crucial for the system to understand your complete travel route. Continuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"ch\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"cch\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Chennai (or airports starting with \"Ch\") are now being suggested by the system. If I can see \"Chennai\" or \"Chennai (MAA)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the destination airport is fundamental to finding the right one-way flight options for your journey, and then I can proceed with setting your November 1st travel date to complete the search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "typing", + "properties": { + "x": 335.94, + "y": 693.06, + "width": 242.19, + "height": 27.78, + "offset_x": 0.0, + "offset_y": 0.0, + "text": "che" + } + } + }, + { + "id": "mission_01_14", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 14, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"c\" has been entered in the destination field, and I'm currently in the process of entering \"Chennai\" as your arrival city for the one-way flight search. Since I need to complete typing the city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"ch\" next, I'm building toward the complete \"Chennai\" entry, which will help the system recognize and suggest the correct Chennai airport option (MAA - Chennai International Airport). This is a critical step in our flight search process because we need to accurately specify your destination location before we can move on to setting November 1st, 2025 as your travel date.\n\nWe're currently at the stage where we're completing the essential route information for your flight search. We've successfully set Hyderabad (HYD) as your departure airport, and now finishing the destination entry is crucial for the system to understand your complete travel route. Continuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"ch\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"cch\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Chennai (or airports starting with \"Ch\") are now being suggested by the system. If I can see \"Chennai\" or \"Chennai (MAA)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the destination airport is fundamental to finding the right one-way flight options for your journey, and then I can proceed with setting your November 1st travel date to complete the search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the booking system has started showing autocomplete suggestions based on the \"ch\" I've typed, but I notice it's showing options like \"China\" and \"CHI Chicago All airports\" rather than Chennai. Since we're specifically looking for Chennai as your destination city for the one-way flight from Hyderabad on November 1st, 2025, I need to continue typing more letters to help the system recognize the correct city.\n\nAt this stage of our flight search process, I'm working on completing the destination city entry, which is crucial for getting accurate flight results for your specific route. The autocomplete feature is active, but it needs more characters to identify Chennai among all the cities that start with \"ch\". By typing \"che\" next, I'll be providing enough letters for the booking system to recognize Chennai and likely display \"Chennai (MAA)\" or \"Chennai International Airport\" in the dropdown suggestions.\n\nThis step is essential because we need both departure and destination cities properly configured before we can proceed with setting your November 1st travel date and executing the search. Once Chennai appears in the suggestions and I can select it, we'll have completed the route information (Hyderabad to Chennai) and can move forward with the final steps to find the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"che\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"chche\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the additional characters I've entered. With \"chche\" now in the field, the autocomplete system should be providing more refined suggestions that are closer to Chennai. I want to verify whether \"Chennai\" or \"Chennai International Airport (MAA)\" has appeared in the dropdown suggestions, as this would allow me to select it directly rather than continuing to type the entire city name.\n\nThis visual verification is crucial at this stage because I'm working on completing the destination city entry, which is one of the final pieces needed before I can set your November 1st travel date and execute the flight search. If Chennai appears in the suggestions, I can click on it to efficiently complete the route information (Hyderabad to Chennai). If the suggestions still don't show Chennai clearly, I'll know to continue typing until the system recognizes your destination city. This step brings us closer to our overall objective of finding the best one-way flight options for your journey from Hyderabad to Chennai on your specified travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"toolUseId\": \"tooluse_c515d8d1\", \"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 328.91, + "y": 743.06, + "width": 256.25, + "height": 77.78, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_15", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 15, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"c\" has been entered in the destination field, and I'm currently in the process of entering \"Chennai\" as your arrival city for the one-way flight search. Since I need to complete typing the city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"ch\" next, I'm building toward the complete \"Chennai\" entry, which will help the system recognize and suggest the correct Chennai airport option (MAA - Chennai International Airport). This is a critical step in our flight search process because we need to accurately specify your destination location before we can move on to setting November 1st, 2025 as your travel date.\n\nWe're currently at the stage where we're completing the essential route information for your flight search. We've successfully set Hyderabad (HYD) as your departure airport, and now finishing the destination entry is crucial for the system to understand your complete travel route. Continuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"ch\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"cch\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Chennai (or airports starting with \"Ch\") are now being suggested by the system. If I can see \"Chennai\" or \"Chennai (MAA)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the destination airport is fundamental to finding the right one-way flight options for your journey, and then I can proceed with setting your November 1st travel date to complete the search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the booking system has started showing autocomplete suggestions based on the \"ch\" I've typed, but I notice it's showing options like \"China\" and \"CHI Chicago All airports\" rather than Chennai. Since we're specifically looking for Chennai as your destination city for the one-way flight from Hyderabad on November 1st, 2025, I need to continue typing more letters to help the system recognize the correct city.\n\nAt this stage of our flight search process, I'm working on completing the destination city entry, which is crucial for getting accurate flight results for your specific route. The autocomplete feature is active, but it needs more characters to identify Chennai among all the cities that start with \"ch\". By typing \"che\" next, I'll be providing enough letters for the booking system to recognize Chennai and likely display \"Chennai (MAA)\" or \"Chennai International Airport\" in the dropdown suggestions.\n\nThis step is essential because we need both departure and destination cities properly configured before we can proceed with setting your November 1st travel date and executing the search. Once Chennai appears in the suggestions and I can select it, we'll have completed the route information (Hyderabad to Chennai) and can move forward with the final steps to find the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"che\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"chche\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the additional characters I've entered. With \"chche\" now in the field, the autocomplete system should be providing more refined suggestions that are closer to Chennai. I want to verify whether \"Chennai\" or \"Chennai International Airport (MAA)\" has appeared in the dropdown suggestions, as this would allow me to select it directly rather than continuing to type the entire city name.\n\nThis visual verification is crucial at this stage because I'm working on completing the destination city entry, which is one of the final pieces needed before I can set your November 1st travel date and execute the flight search. If Chennai appears in the suggestions, I can click on it to efficiently complete the route information (Hyderabad to Chennai). If the suggestions still don't show Chennai clearly, I'll know to continue typing until the system recognizes your destination city. This step brings us closer to our overall objective of finding the best one-way flight options for your journey from Hyderabad to Chennai on your specified travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"toolUseId\": \"tooluse_c515d8d1\", \"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"MAA Chennai International Airport\" has appeared at the top of the dropdown suggestions, which is exactly what we need for your destination city. This is the correct Chennai airport for your one-way flight search from Hyderabad on November 1st, 2025.\n\nAt this stage of our flight booking process, I'm completing the essential route information by selecting the proper destination airport. We've successfully configured Hyderabad (HYD) as your departure city, and now clicking on \"MAA Chennai International Airport\" will finalize your destination selection. This step is crucial because having both departure and arrival airports properly specified is fundamental for the booking system to provide accurate flight options, schedules, and pricing.\n\nBy clicking on this Chennai airport option from the dropdown, I'll efficiently complete the route configuration without having to type out the entire city name, which reduces the chance of errors and moves us forward more quickly. Once this destination selection is confirmed, we'll have all the location information needed (Hyderabad to Chennai), and I can then proceed to the final step of setting your November 1st, 2025 travel date before executing the search to find the best available one-way flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 292.58000000000004, \"y\": 410.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"MAA Chennai International Airport\" from the dropdown menu to complete your destination selection, and now I need to verify that this choice has been properly registered in the booking system. At this crucial stage of our flight search process, I'm working on confirming that both your departure city (Hyderabad) and destination city (Chennai) are correctly configured before we proceed to set your November 1st, 2025 travel date.\n\nTaking a screenshot at this moment is essential because I need to see the current state of the search form and confirm that Chennai has been successfully entered as your destination. This visual verification will show me whether the destination field now displays \"Chennai\" or \"MAA\" correctly, which validates that our selection was processed properly by the booking system. It will also help me assess the overall form status and identify exactly where to click next to set your travel date.\n\nThis step is critical for our overall objective of finding your one-way flight from Hyderabad to Chennai because I need to ensure all the route information is accurate before moving to the final configuration step. Once I can visually confirm that both cities are properly set in the search form, I'll be able to proceed confidently with setting your November 1st travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 531.25, + "y": 543.06, + "width": 151.56, + "height": 66.67, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_16", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 16, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"c\" has been entered in the destination field, and I'm currently in the process of entering \"Chennai\" as your arrival city for the one-way flight search. Since I need to complete typing the city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"ch\" next, I'm building toward the complete \"Chennai\" entry, which will help the system recognize and suggest the correct Chennai airport option (MAA - Chennai International Airport). This is a critical step in our flight search process because we need to accurately specify your destination location before we can move on to setting November 1st, 2025 as your travel date.\n\nWe're currently at the stage where we're completing the essential route information for your flight search. We've successfully set Hyderabad (HYD) as your departure airport, and now finishing the destination entry is crucial for the system to understand your complete travel route. Continuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"ch\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"cch\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Chennai (or airports starting with \"Ch\") are now being suggested by the system. If I can see \"Chennai\" or \"Chennai (MAA)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the destination airport is fundamental to finding the right one-way flight options for your journey, and then I can proceed with setting your November 1st travel date to complete the search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the booking system has started showing autocomplete suggestions based on the \"ch\" I've typed, but I notice it's showing options like \"China\" and \"CHI Chicago All airports\" rather than Chennai. Since we're specifically looking for Chennai as your destination city for the one-way flight from Hyderabad on November 1st, 2025, I need to continue typing more letters to help the system recognize the correct city.\n\nAt this stage of our flight search process, I'm working on completing the destination city entry, which is crucial for getting accurate flight results for your specific route. The autocomplete feature is active, but it needs more characters to identify Chennai among all the cities that start with \"ch\". By typing \"che\" next, I'll be providing enough letters for the booking system to recognize Chennai and likely display \"Chennai (MAA)\" or \"Chennai International Airport\" in the dropdown suggestions.\n\nThis step is essential because we need both departure and destination cities properly configured before we can proceed with setting your November 1st travel date and executing the search. Once Chennai appears in the suggestions and I can select it, we'll have completed the route information (Hyderabad to Chennai) and can move forward with the final steps to find the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"che\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"chche\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the additional characters I've entered. With \"chche\" now in the field, the autocomplete system should be providing more refined suggestions that are closer to Chennai. I want to verify whether \"Chennai\" or \"Chennai International Airport (MAA)\" has appeared in the dropdown suggestions, as this would allow me to select it directly rather than continuing to type the entire city name.\n\nThis visual verification is crucial at this stage because I'm working on completing the destination city entry, which is one of the final pieces needed before I can set your November 1st travel date and execute the flight search. If Chennai appears in the suggestions, I can click on it to efficiently complete the route information (Hyderabad to Chennai). If the suggestions still don't show Chennai clearly, I'll know to continue typing until the system recognizes your destination city. This step brings us closer to our overall objective of finding the best one-way flight options for your journey from Hyderabad to Chennai on your specified travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"toolUseId\": \"tooluse_c515d8d1\", \"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"MAA Chennai International Airport\" has appeared at the top of the dropdown suggestions, which is exactly what we need for your destination city. This is the correct Chennai airport for your one-way flight search from Hyderabad on November 1st, 2025.\n\nAt this stage of our flight booking process, I'm completing the essential route information by selecting the proper destination airport. We've successfully configured Hyderabad (HYD) as your departure city, and now clicking on \"MAA Chennai International Airport\" will finalize your destination selection. This step is crucial because having both departure and arrival airports properly specified is fundamental for the booking system to provide accurate flight options, schedules, and pricing.\n\nBy clicking on this Chennai airport option from the dropdown, I'll efficiently complete the route configuration without having to type out the entire city name, which reduces the chance of errors and moves us forward more quickly. Once this destination selection is confirmed, we'll have all the location information needed (Hyderabad to Chennai), and I can then proceed to the final step of setting your November 1st, 2025 travel date before executing the search to find the best available one-way flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 292.58000000000004, \"y\": 410.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"MAA Chennai International Airport\" from the dropdown menu to complete your destination selection, and now I need to verify that this choice has been properly registered in the booking system. At this crucial stage of our flight search process, I'm working on confirming that both your departure city (Hyderabad) and destination city (Chennai) are correctly configured before we proceed to set your November 1st, 2025 travel date.\n\nTaking a screenshot at this moment is essential because I need to see the current state of the search form and confirm that Chennai has been successfully entered as your destination. This visual verification will show me whether the destination field now displays \"Chennai\" or \"MAA\" correctly, which validates that our selection was processed properly by the booking system. It will also help me assess the overall form status and identify exactly where to click next to set your travel date.\n\nThis step is critical for our overall objective of finding your one-way flight from Hyderabad to Chennai because I need to ensure all the route information is accurate before moving to the final configuration step. Once I can visually confirm that both cities are properly set in the search form, I'll be able to proceed confidently with setting your November 1st travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that both your departure and destination cities have been successfully configured in the search form. The system now shows \"HYD Rajiv Gandhi International Airport\" as your departure location and \"MAA Chennai International Airport\" as your destination, which perfectly matches your request for a flight from Hyderabad to Chennai.\n\nNow I'm at the final crucial stage of setting up your flight search - configuring the travel date. I can see the \"Travel date\" field currently shows \"Sat 25 Oct\" as a default date, but since you specifically requested travel on November 1st, 2025, I need to update this to match your requirements exactly.\n\nClicking on the travel date field makes perfect sense at this point because it's the last essential piece of information needed to complete your one-way flight search. Once I activate this date selector, I'll be able to navigate to November 2025 and select the 1st as your departure date. This step is critical for our overall objective because the booking system needs the exact travel date to provide accurate flight schedules, availability, and pricing for your specific journey from Hyderabad to Chennai.\n\nWith all the route information properly configured (departure: HYD, destination: MAA, trip type: one-way), setting the correct travel date will complete all the necessary search parameters, allowing us to execute the search and find the best available flight options for your November 1st, 2025 travel plans.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_B-Wi6wZrQteOZJBizODAwg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 341.405, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_B-Wi6wZrQteOZJBizODAwg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the travel date field to set your departure date to November 1st, 2025, and now I need to see how the date selection interface has responded to this action. At this final stage of configuring your one-way flight search from Hyderabad to Chennai, I'm working on setting the correct travel date, which is the last essential piece of information needed before we can execute the search.\n\nTaking a screenshot at this moment is crucial because I need to see what type of date picker or calendar interface has appeared after clicking on the travel date field. This visual confirmation will show me whether a calendar has opened up, what month and year are currently displayed, and how I can navigate to November 2025 to select the 1st as your departure date. Different booking platforms use various date selection methods - some show dropdown menus, others display full calendar grids, and some use date input fields - so seeing the current interface will help me determine the most efficient way to set your specific travel date.\n\nThis step is essential for completing your flight search setup because we've successfully configured all the route information (HYD to MAA, one-way trip), and now accurately setting November 1st, 2025 as your travel date will provide the booking system with all the parameters needed to find the best available flight options, schedules, and pricing for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_-s_4IvdIQYOpyOuHXhNppQ", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_-s_4IvdIQYOpyOuHXhNppQ", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_-s_4IvdIQYOpyOuHXhNppQ", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 614.26, + "y": 759.72, + "width": 28.01, + "height": 61.11, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + }, + { + "id": "mission_01_17", + "mission_id": "mission_01", + "mission": "search for one way flight from hyd to chennai on nov 1 2025", + "date": "2025-11-11 15:12:56", + "navigational_directions": "", + "turn": 17, + "chat_history": [ + { + "role": "system", + "content": [ + { + "text": "\nYou are a web automation agent. Follow these strict rules when interacting with web pages:\n\n1. Element Interaction (Clicking)\n - Identify and click the most relevant or appropriate element that matches the user\u2019s intent.\n - If multiple matching elements exist, choose the most likely correct one based on context.\n\n2. Typing and Autosuggestions\n - Before begining to type make sure to click on the element where you are typing, as you are unaware if the element is on focus.\n - Always type text character by character instead of whole text (unless mentioned specifically in user prompt) to make use of auto-suggestions where possible.\n - Monitor for autosuggestions or autocomplete options that appear while typing.\n - Only click or select a suggested element if it clearly matches the user\u2019s intent or improves accuracy.\n - Otherwise, continue typing normally.\n\n3. Scrolling\n - If the desired element is not visible on screen, scroll until it is located.\n - Use minimal scrolling and stop immediately once the element is found.\n\n4. Loading and Waiting\n - Detect when the page is loading or updating (e.g., network activity, spinners, or DOM changes).\n - Wait until the page has fully loaded or stabilized before taking the next action.\n - By default when waiting for the page to load, wait for 2 seconds before taking the next action. \n\n5. Authentication and Captchas\n - If a captcha or authentication prompt is encountered, do not attempt to bypass it.\n - Immediately pause automation and return control to the user with a clear message that manual action is required.\n\n6. Safety\n - Always prioritize accuracy, stability, and safe interactions.\n\n7. Modals and Pop-ups\n - Always close any pop-up modals, cookie consent banners, or overlays that may obstruct interaction with the main page content before proceeding with further actions.\n - If unsure or user intends to perform action without closing modals follow user instructions.\n", + "type": "text" + } + ] + }, + { + "role": "user", + "content": [ + { + "text": "Help me now to complete the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I'll help you search for a one-way flight from Hyderabad to Chennai on November 1st, 2025. To get started with this flight search, I need to first see what's currently displayed on the screen to understand which travel website or booking platform we're working with.\n\nTaking a screenshot will allow me to assess the current state of the page and identify the search interface elements like departure city, destination city, date selectors, and flight type options. This is the essential first step before I can proceed with entering your specific travel details - the route from HYD to Chennai and your preferred travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_O5Dr64r9RC-lW8BNsdHTng", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see we're on Booking.com, which is currently showing the hotel search interface. Since you're looking for flights from Hyderabad to Chennai, I need to switch to the flights section of the website first. \n\nLooking at the navigation menu at the top, I can see there's a \"Flights\" tab that will take us to the flight booking interface where we can search for your specific route and date. This is the logical first step since we're currently on the accommodation booking page, but we need to access the flight search functionality to find your one-way ticket from HYD to Chennai on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 114.24000000000001, \"y\": 77.775}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_KPL8V74WTKCpbOP7f6Nvfg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I need to take a screenshot to see if the page has successfully loaded the flights section after clicking on the Flights tab. This is a crucial step in our flight search process because I need to verify that we've properly navigated to the flight booking interface where we can enter your specific travel details.\n\nCurrently, we're in the middle of transitioning from the hotel booking page to the flights section of Booking.com. Taking a screenshot will allow me to confirm that the page has loaded correctly and show me the flight search form with all the necessary fields - departure city, destination city, travel dates, and trip type options. This visual confirmation is essential before I can proceed with entering \"Hyderabad\" as your departure city, \"Chennai\" as your destination, selecting \"November 1, 2025\" as your travel date, and ensuring the search is set for a one-way flight rather than round-trip.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_cGo8Le0NTGGuAMMe1sxfhw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see we've successfully navigated to the flights section of Booking.com. Now I can see the flight search form with all the necessary options. I notice that \"Round trip\" is currently selected by default, but since you specifically requested a one-way flight from Hyderabad to Chennai, I need to change this to \"One way\" first.\n\nThis is a crucial step in our flight search process because selecting the correct trip type will ensure we get accurate pricing and availability for your specific travel needs. By clicking on \"One way\", I'll configure the search to show only one-way flights rather than round-trip options, which will give you the exact type of booking you're looking for on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 118.965, \"y\": 259.03}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_EXntkIUoR9ynRr9jgbNWzA", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Great! I've selected \"One way\" for your flight search. Now I need to verify that this selection has been properly applied and see the current state of the search form before proceeding with entering your specific travel details.\n\nTaking a screenshot at this point is essential because I want to confirm that the flight search interface has updated correctly to reflect the one-way trip selection. This visual confirmation will show me that we're now properly configured for a one-way search, and I can then see all the input fields clearly - the departure city field where I'll enter \"Hyderabad\" (HYD), the destination field for \"Chennai\", and the date selector where I'll set November 1st, 2025.\n\nThis is a critical stage in our flight booking process because I need to ensure the form is ready to accept your travel information accurately. Once I can see that the one-way option is active and all fields are visible and accessible, I can proceed systematically to fill in each piece of your travel requirements to find the best flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_srJ4YviFQYaKLsWr5KKM9A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"One way\" is now selected, which is exactly what we need for your flight search. The form has updated correctly and now shows a single \"Travel date\" field instead of the previous round-trip date range, which confirms we're properly configured for a one-way flight.\n\nNow I'm ready to start entering your specific travel details. The first step is to specify your departure city, which is Hyderabad. I can see the \"Leaving from\" field is currently empty and ready for input. Clicking on this field will allow me to enter \"Hyderabad\" as your departure airport, which is a crucial piece of information for finding flights on your desired route to Chennai.\n\nThis is an important stage in our flight search process because accurately specifying the departure city ensures we get relevant flight options from the correct airport. Once I enter Hyderabad in this field, the system will be able to search for flights departing from HYD airport, bringing us one step closer to finding your ideal flight on November 1st, 2025.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 142.57999999999998, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_nVQuKrP5T5O1fSB4dkkHYQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the \"Leaving from\" field to start entering your departure city, but I need to verify that the field is now active and ready for text input. At this stage of our flight search process, I'm working on entering the first piece of your travel information - specifying Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the departure field and confirm whether it's properly focused and ready to accept text input. This visual confirmation is essential because I need to see if a text cursor has appeared in the field, if any dropdown suggestions have opened, or if there are any other interface changes that indicate the field is active. \n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the departure city field is properly activated before I can type \"Hyderabad\" into it. Once I can see that the field is ready for input, I'll be able to proceed confidently with entering your departure city, which will then allow me to move on to specifying Chennai as your destination and setting your travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZezBh0WIR86JCgC-NBgt6A", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that the departure city field is now active and ready for input - there's a blue text input box that has appeared below the \"Leaving from\" field. This is exactly what we need to proceed with entering your departure city.\n\nNow I'm at the crucial stage of inputting your specific travel details for the flight search. Since you're looking for a flight from Hyderabad to Chennai, I need to enter \"Hyderabad\" in this departure field. I can see the input box is positioned and ready to accept text, which means clicking directly in the center of this blue input field will allow me to start typing your departure city.\n\nThis step is essential for our flight search because accurately specifying Hyderabad as your departure location will ensure the booking system searches for flights from the correct airport (HYD). Once I click in this input field and enter \"Hyderabad\", the system will likely show airport suggestions, allowing me to select the specific Hyderabad airport. This precision in entering your departure city is fundamental to finding the right flight options for your November 1st, 2025 journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 167.57999999999998, \"y\": 340.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_kO6LpP3RRC-78T13kYXwgQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that I've clicked on the departure city input field, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on entering the first crucial piece of your travel information - specifying Hyderabad as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot at this moment is essential because I need to confirm that the input field has been properly activated and is ready to accept text. This visual verification will show me whether a text cursor has appeared in the field, indicating that it's focused and ready for typing. It will also help me see if any dropdown menus or autocomplete suggestions have appeared, which would be important for selecting the correct Hyderabad airport option.\n\nThis step is critical for our overall objective because I need to ensure the departure field is properly prepared before I can type \"Hyderabad\" into it. Once I can visually confirm that the field is active and ready, I'll be able to proceed confidently with entering your departure city, which will then allow me to move forward with specifying Chennai as your destination and setting your November 1st travel date to complete the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_vGWpvT5uTw6-UJA6WSyIwA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the departure city input field is now active and ready for text entry. Since we're at the stage where I need to enter \"Hyderabad\" as your departure city for the one-way flight search, I should start typing the city name into this focused input field.\n\nThe typing tool is the most logical next step here because the blue input box is clearly visible and positioned to accept text input. By starting to type \"Hyderabad\", the booking system will likely recognize the city and provide autocomplete suggestions, making it easier to select the correct Hyderabad airport (HYD). This is a crucial stage in our flight search process because accurately specifying your departure location is essential for finding relevant flight options.\n\nOnce I enter the departure city, I'll be able to move forward with the remaining steps - setting Chennai as your destination and selecting November 1st, 2025 as your travel date. This systematic approach to filling out the search form will ensure we get accurate results for your specific one-way flight requirements.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"h\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_03mm7F--SfW0_fynMnCjaQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"h\" in the departure city field, and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm in the middle of entering \"Hyderabad\" as your departure city for the one-way flight to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see if the booking system has started showing autocomplete suggestions or dropdown options based on the letter \"h\" I just typed. Many flight booking platforms display a list of cities and airports that begin with the letters you've entered, which would help me quickly identify and select the correct Hyderabad airport option. \n\nThis visual confirmation will show me whether any city suggestions have appeared, and if so, I can see exactly which Hyderabad option to select (likely showing \"Hyderabad (HYD)\" or similar). If no suggestions have appeared yet, I'll know I need to continue typing more letters of \"Hyderabad\" until the system recognizes the city. This step is crucial for ensuring accuracy in our flight search, as selecting the correct departure airport is fundamental to finding the right flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Zp0s0sz3SFe5w3oWyzc68w", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"h\" has been entered in the departure city field, and I'm currently in the process of entering \"Hyderabad\" as your departure city for the one-way flight search. Since I need to complete typing the full city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"hy\" next, I'm building toward the complete \"Hyderabad\" entry, which will help the system recognize and suggest the correct Hyderabad airport option (HYD). This is a critical step in our flight search process because we need to accurately specify your departure location before we can move on to entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nContinuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"hy\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_BTcpzTw9SBCs_uw_ux26UQ", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"hhy\" in the departure city field as I continue building the complete \"Hyderabad\" entry for your flight search. At this stage of our booking process, I'm systematically entering your departure city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Hyderabad (or airports starting with \"Hy\") are now being suggested by the system. If I can see \"Hyderabad\" or \"Hyderabad (HYD)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the departure airport is fundamental to finding the right one-way flight options for your journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ngK_XXfQRo-bned17DM8LA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the booking system has recognized the letters \"hy\" and is now displaying a dropdown list of airport suggestions. This is exactly what we needed to happen in our flight search process. \n\nLooking at the suggestions, I can see \"HYD Rajiv Gandhi International Airport\" at the top of the list, which is precisely the Hyderabad airport we need for your departure city. This is the correct airport for flights departing from Hyderabad, and it's showing the full details including \"Hyderabad, Telangana, India\" which confirms this is the right option.\n\nAt this stage of our flight booking process, I'm working on accurately selecting your departure airport so we can proceed with the rest of your travel details. Since the system has provided the exact airport option we need, clicking on \"HYD Rajiv Gandhi International Airport\" will efficiently complete the departure city selection without having to type out the entire city name. This approach ensures accuracy and moves us forward quickly toward entering Chennai as your destination and setting November 1st, 2025 as your travel date.\n\nSelecting the correct departure airport from this dropdown is crucial because it will ensure our search results show flights departing from the right location for your one-way journey to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 171.095, \"y\": 390.97499999999997}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_iBssjk6jQXeCOEhbr37Wcw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"HYD Rajiv Gandhi International Airport\" from the dropdown menu as your departure airport, which is a crucial step in setting up your one-way flight search from Hyderabad to Chennai. At this stage of our booking process, I need to verify that the departure city selection has been properly registered in the system before moving forward with the next steps.\n\nTaking a screenshot right now will allow me to confirm that Hyderabad has been successfully entered as your departure location and see the current state of the search form. This visual verification is essential because I need to ensure the departure field now displays \"Hyderabad\" or \"HYD\" correctly, which will validate that our selection was processed properly by the booking system.\n\nOnce I can see that the departure city is confirmed, I'll be able to proceed confidently to the next critical step - entering Chennai as your destination city. This systematic approach ensures accuracy in our flight search process and brings us closer to finding the best one-way flight options for your November 1st, 2025 travel date. The screenshot will also show me the current layout of the form, helping me identify exactly where to click next to enter your destination city.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_1MRbUugLQkaD6EiO0En_dg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that \"HYD Rajiv Gandhi International Airport\" has been successfully selected and is now displayed in the departure field. This confirms that Hyderabad is properly set as your departure city for the one-way flight search.\n\nNow I'm at the next crucial stage of our flight booking process - entering your destination city, which is Chennai. I can see the \"Going to\" field is currently empty and ready for input. Since we've successfully configured the departure location, specifying Chennai as your destination is the logical next step to complete the route information for your November 1st, 2025 flight.\n\nClicking on the destination field will activate it and allow me to enter Chennai, which will then enable the booking system to search for flights on the specific route you need: Hyderabad to Chennai. This step is essential because the system needs both departure and arrival cities to provide accurate flight options, pricing, and schedules. Once I have both cities entered, I'll be able to proceed with setting your travel date and ultimately search for the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 264.065, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ttJe6iOjQReuYMAu-xdi1g", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination field to start entering Chennai as your arrival city, and now I need to verify that the field is properly activated and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if any input box has appeared similar to what happened with the departure city field. It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering \"Chennai.\"\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ze49iS4XQtqyy7fWKWb3xA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that the destination field has been activated and is now showing a search interface for entering your arrival city. There's a clear input box labeled \"Airport, city or country\" which is exactly what I need to specify Chennai as your destination.\n\nAt this stage of our flight booking process, I'm working on completing the essential route information for your one-way flight search. We've successfully set Hyderabad (HYD) as your departure city, and now I need to enter Chennai to complete the flight route. The input field is positioned and ready to accept text, which means I can click directly in the center of this blue input box to start typing \"Chennai.\"\n\nThis step is crucial because the booking system needs both your departure and destination cities to provide accurate flight options, schedules, and pricing for your November 1st, 2025 travel date. By clicking in this input field and entering Chennai, I'll be able to trigger the system's autocomplete feature, which will likely show Chennai airport options (such as MAA - Chennai International Airport) that I can select from. This approach ensures accuracy and moves us efficiently toward the final step of setting your travel date and executing the flight search to find the best one-way options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 289.065, \"y\": 360.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_dG-D7RyZQSKB7ocVadN1Sg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the destination input field to enter Chennai as your arrival city, and now I need to verify that the field is properly focused and ready for text input. At this stage of our flight search process, I'm working on completing the second essential piece of your travel route - specifying Chennai as your destination after successfully setting Hyderabad as your departure city.\n\nTaking a screenshot right now will show me the current state of the destination field and confirm whether it's focused and ready to accept text. This visual verification is important because I need to see if the field has been activated with a text cursor, or if the input interface has changed in any way that would affect how I enter \"Chennai.\" It will also help me identify the exact position and state of the destination field so I can proceed confidently with entering your arrival city.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because I need to ensure the destination field is properly prepared before typing Chennai into it. Once I can visually confirm that the field is active and ready, I'll be able to enter your destination city accurately, which will then allow me to move forward with setting your November 1st travel date and completing the flight search to find the best available options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_Hs8fkRkXQnun-B7yNqdhuA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the destination input field is now active and ready for text entry. Since we're at the stage where I need to enter Chennai as your arrival city to complete the flight route information, I should start typing the city name into this focused input field.\n\nWe've successfully configured Hyderabad (HYD) as your departure airport, and now completing the destination is the logical next step in our flight search process. By starting to type \"Chennai\" with the letter \"c\", the booking system will likely begin showing autocomplete suggestions for cities and airports that start with that letter. This approach is efficient because most flight booking platforms provide helpful dropdown suggestions as you type, which will allow me to quickly identify and select Chennai International Airport (MAA) from the list.\n\nThis step is crucial for our overall objective of finding your one-way flight from Hyderabad to Chennai on November 1st, 2025, because the system needs both departure and destination cities to provide accurate flight options and pricing. Once I enter the destination city, I'll be able to proceed with setting your specific travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"c\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_8obheIrfQxOMkQxhkUbZrA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've started typing \"c\" in the destination field as the first letter of \"Chennai\", and now I need to see how the booking system is responding to this input. At this stage of our flight search process, I'm working on completing the destination city entry after successfully setting up Hyderabad as your departure location for the one-way flight on November 1st, 2025.\n\nTaking a screenshot right now makes perfect sense because I need to see if the booking system has started displaying autocomplete suggestions based on the letter \"c\" I just entered. Most flight booking platforms show a dropdown list of cities and airports that begin with the letters you've typed, which would help me quickly identify Chennai or Chennai International Airport from the suggestions. This visual confirmation will show me whether any city options have appeared, and if so, I can see exactly which Chennai airport option to select (likely \"Chennai (MAA)\" or similar).\n\nThis step is crucial for our overall objective because I need to verify that the system is recognizing my input and providing relevant suggestions. If Chennai appears in the dropdown, I can click on it directly rather than typing the entire city name, which is more efficient and reduces the chance of errors. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes Chennai. This approach ensures we accurately complete the route information needed to find the best one-way flight options from Hyderabad to Chennai for your November 1st travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_uwWI4VVJTBWjfSKey03Skw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the letter \"c\" has been entered in the destination field, and I'm currently in the process of entering \"Chennai\" as your arrival city for the one-way flight search. Since I need to complete typing the city name to get accurate search results, continuing to type the next letters makes perfect sense at this stage.\n\nThe booking system typically requires more characters before it can provide meaningful autocomplete suggestions for cities and airports. By typing \"ch\" next, I'm building toward the complete \"Chennai\" entry, which will help the system recognize and suggest the correct Chennai airport option (MAA - Chennai International Airport). This is a critical step in our flight search process because we need to accurately specify your destination location before we can move on to setting November 1st, 2025 as your travel date.\n\nWe're currently at the stage where we're completing the essential route information for your flight search. We've successfully set Hyderabad (HYD) as your departure airport, and now finishing the destination entry is crucial for the system to understand your complete travel route. Continuing to type the city name systematically ensures we'll get the right airport suggestions and ultimately find the most suitable one-way flight options for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"ch\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_pkdh3jhWSq6eUGIeVJg1QA", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"cch\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the characters I've entered so far. Many flight booking platforms start displaying autocomplete suggestions once you've typed a few letters, and I want to check if any city or airport options have appeared in a dropdown menu below the input field. \n\nThis visual verification will show me whether Chennai (or airports starting with \"Ch\") are now being suggested by the system. If I can see \"Chennai\" or \"Chennai (MAA)\" in the suggestions, I'll be able to click on it directly rather than typing out the entire city name. This approach is more efficient and reduces the chance of typos. If no suggestions have appeared yet, I'll know to continue typing more letters until the system recognizes the city. This step is crucial for our overall objective because accurately selecting the destination airport is fundamental to finding the right one-way flight options for your journey, and then I can proceed with setting your November 1st travel date to complete the search.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_TJQqZgMCRZa_AYoSscs1lg", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I can see that the booking system has started showing autocomplete suggestions based on the \"ch\" I've typed, but I notice it's showing options like \"China\" and \"CHI Chicago All airports\" rather than Chennai. Since we're specifically looking for Chennai as your destination city for the one-way flight from Hyderabad on November 1st, 2025, I need to continue typing more letters to help the system recognize the correct city.\n\nAt this stage of our flight search process, I'm working on completing the destination city entry, which is crucial for getting accurate flight results for your specific route. The autocomplete feature is active, but it needs more characters to identify Chennai among all the cities that start with \"ch\". By typing \"che\" next, I'll be providing enough letters for the booking system to recognize Chennai and likely display \"Chennai (MAA)\" or \"Chennai International Airport\" in the dropdown suggestions.\n\nThis step is essential because we need both departure and destination cities properly configured before we can proceed with setting your November 1st travel date and executing the search. Once Chennai appears in the suggestions and I can select it, we'll have completed the route information (Hyderabad to Chennai) and can move forward with the final steps to find the best one-way flight options available for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "type": "function", + "function": { + "name": "typing_tool", + "arguments": "{\"text\": \"che\"}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_VUl8YxcvRW2B9IbDN5-raw", + "name": "typing_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've now typed \"chche\" in the destination field as I continue building the complete \"Chennai\" entry for your flight search. At this stage of our booking process, I'm systematically entering your destination city to ensure we get accurate flight options from Hyderabad to Chennai on November 1st, 2025.\n\nTaking a screenshot right now is essential because I need to see how the booking system is responding to the additional characters I've entered. With \"chche\" now in the field, the autocomplete system should be providing more refined suggestions that are closer to Chennai. I want to verify whether \"Chennai\" or \"Chennai International Airport (MAA)\" has appeared in the dropdown suggestions, as this would allow me to select it directly rather than continuing to type the entire city name.\n\nThis visual verification is crucial at this stage because I'm working on completing the destination city entry, which is one of the final pieces needed before I can set your November 1st travel date and execute the flight search. If Chennai appears in the suggestions, I can click on it to efficiently complete the route information (Hyderabad to Chennai). If the suggestions still don't show Chennai clearly, I'll know to continue typing until the system recognizes your destination city. This step brings us closer to our overall objective of finding the best one-way flight options for your journey from Hyderabad to Chennai on your specified travel date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"toolUseId\": \"tooluse_c515d8d1\", \"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_filPxuqoQxyx6Vue5wmgGA", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that \"MAA Chennai International Airport\" has appeared at the top of the dropdown suggestions, which is exactly what we need for your destination city. This is the correct Chennai airport for your one-way flight search from Hyderabad on November 1st, 2025.\n\nAt this stage of our flight booking process, I'm completing the essential route information by selecting the proper destination airport. We've successfully configured Hyderabad (HYD) as your departure city, and now clicking on \"MAA Chennai International Airport\" will finalize your destination selection. This step is crucial because having both departure and arrival airports properly specified is fundamental for the booking system to provide accurate flight options, schedules, and pricing.\n\nBy clicking on this Chennai airport option from the dropdown, I'll efficiently complete the route configuration without having to type out the entire city name, which reduces the chance of errors and moves us forward more quickly. Once this destination selection is confirmed, we'll have all the location information needed (Hyderabad to Chennai), and I can then proceed to the final step of setting your November 1st, 2025 travel date before executing the search to find the best available one-way flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 292.58000000000004, \"y\": 410.41999999999996}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_ZXN4c-pnQViuIiQbAh3dtQ", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected \"MAA Chennai International Airport\" from the dropdown menu to complete your destination selection, and now I need to verify that this choice has been properly registered in the booking system. At this crucial stage of our flight search process, I'm working on confirming that both your departure city (Hyderabad) and destination city (Chennai) are correctly configured before we proceed to set your November 1st, 2025 travel date.\n\nTaking a screenshot at this moment is essential because I need to see the current state of the search form and confirm that Chennai has been successfully entered as your destination. This visual verification will show me whether the destination field now displays \"Chennai\" or \"MAA\" correctly, which validates that our selection was processed properly by the booking system. It will also help me assess the overall form status and identify exactly where to click next to set your travel date.\n\nThis step is critical for our overall objective of finding your one-way flight from Hyderabad to Chennai because I need to ensure all the route information is accurate before moving to the final configuration step. Once I can visually confirm that both cities are properly set in the search form, I'll be able to proceed confidently with setting your November 1st travel date and then execute the search to find the best available flight options for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_hkvUBzhGSKWVWWSbQohvtw", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Excellent! I can see that both your departure and destination cities have been successfully configured in the search form. The system now shows \"HYD Rajiv Gandhi International Airport\" as your departure location and \"MAA Chennai International Airport\" as your destination, which perfectly matches your request for a flight from Hyderabad to Chennai.\n\nNow I'm at the final crucial stage of setting up your flight search - configuring the travel date. I can see the \"Travel date\" field currently shows \"Sat 25 Oct\" as a default date, but since you specifically requested travel on November 1st, 2025, I need to update this to match your requirements exactly.\n\nClicking on the travel date field makes perfect sense at this point because it's the last essential piece of information needed to complete your one-way flight search. Once I activate this date selector, I'll be able to navigate to November 2025 and select the 1st as your departure date. This step is critical for our overall objective because the booking system needs the exact travel date to provide accurate flight schedules, availability, and pricing for your specific journey from Hyderabad to Chennai.\n\nWith all the route information properly configured (departure: HYD, destination: MAA, trip type: one-way), setting the correct travel date will complete all the necessary search parameters, allowing us to execute the search and find the best available flight options for your November 1st, 2025 travel plans.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_B-Wi6wZrQteOZJBizODAwg", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 341.405, \"y\": 304.86499999999995}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_B-Wi6wZrQteOZJBizODAwg", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've clicked on the travel date field to set your departure date to November 1st, 2025, and now I need to see how the date selection interface has responded to this action. At this final stage of configuring your one-way flight search from Hyderabad to Chennai, I'm working on setting the correct travel date, which is the last essential piece of information needed before we can execute the search.\n\nTaking a screenshot at this moment is crucial because I need to see what type of date picker or calendar interface has appeared after clicking on the travel date field. This visual confirmation will show me whether a calendar has opened up, what month and year are currently displayed, and how I can navigate to November 2025 to select the 1st as your departure date. Different booking platforms use various date selection methods - some show dropdown menus, others display full calendar grids, and some use date input fields - so seeing the current interface will help me determine the most efficient way to set your specific travel date.\n\nThis step is essential for completing your flight search setup because we've successfully configured all the route information (HYD to MAA, one-way trip), and now accurately setting November 1st, 2025 as your travel date will provide the booking system with all the parameters needed to find the best available flight options, schedules, and pricing for your journey from Hyderabad to Chennai.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_-s_4IvdIQYOpyOuHXhNppQ", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_-s_4IvdIQYOpyOuHXhNppQ", + "name": "screenshot_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "Perfect! I can see that a calendar interface has opened up, displaying both October 2025 and November 2025 side by side. This is exactly what we need to complete your flight search setup. I can clearly see November 2025 on the right side of the calendar, and I need to select the 1st of November as your departure date.\n\nAt this final stage of configuring your one-way flight search from Hyderabad to Chennai, I'm working on setting the precise travel date you requested. We've successfully established all the essential route information - departure from HYD Rajiv Gandhi International Airport, destination to MAA Chennai International Airport, and confirmed it's a one-way trip. Now selecting November 1st, 2025 from this calendar will complete all the necessary search parameters.\n\nI can see the number \"1\" in the November 2025 calendar section, which represents November 1st - exactly the date you specified for your travel. Clicking on this date will finalize your travel date selection and provide the booking system with all the information needed to search for available flights, schedules, and pricing options for your specific journey. This action will complete the search configuration and allow us to proceed with finding the best one-way flight options from Hyderabad to Chennai on your preferred date.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_g5FDbNr3S0SXKAKTw6M6cw", + "type": "function", + "function": { + "name": "click_tool", + "arguments": "{\"x\": 321.135, \"y\": 410.415}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_g5FDbNr3S0SXKAKTw6M6cw", + "name": "click_tool", + "content": "success" + }, + { + "role": "user", + "content": [ + { + "text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "type": "text" + } + ] + }, + { + "content": "I've just selected November 1st, 2025 from the calendar as your departure date, which completes the final piece of information needed for your one-way flight search from Hyderabad to Chennai. At this crucial stage of our booking process, I need to verify that the date selection has been properly registered and see the current state of the complete search form.\n\nTaking a screenshot right now makes perfect sense because I want to confirm that all your travel details have been accurately configured before we proceed to execute the search. This visual verification will show me whether November 1st, 2025 is now properly displayed in the travel date field, and I can also double-check that we still have the correct departure city (HYD Rajiv Gandhi International Airport), destination (MAA Chennai International Airport), and trip type (one-way) all properly set.\n\nThis verification step is essential at this stage because we're about to transition from configuring your search parameters to actually executing the flight search. I want to ensure that every detail matches your specific requirements - the route from Hyderabad to Chennai, the one-way trip type, and the November 1st, 2025 travel date - before we move forward with finding available flight options. Once I can visually confirm that all the search criteria are correctly established, we'll be ready to execute the search and discover the best flight options, schedules, and pricing for your journey.", + "role": "assistant", + "tool_calls": [ + { + "id": "tooluse_zToky2ViQRqK79xSegYsEg", + "type": "function", + "function": { + "name": "screenshot_tool", + "arguments": "{\"toolUseId\": \"tooluse_2db10c61\", \"take_screenshot\": true}" + } + } + ] + }, + { + "role": "tool", + "tool_call_id": "tooluse_zToky2ViQRqK79xSegYsEg", + "name": "screenshot_tool", + "content": "success" + } + ], + "current_user_text": "You are now midway through the assigned mission. Recommend the optimal next step to drive it toward completion. For typing tasks: type only ONE character at a time - look at what text is currently visible in the input field and add just the next single character needed to build toward your target word. When using typing_tool, return the COMPLETE expected text after adding your single character (e.g., if you see 'Hy' and type 'd', return 'Hyd'). Never type multiple characters or word fragments at once.", + "current_tool_result": { + "role": "tool", + "tool_call_id": "tooluse_zToky2ViQRqK79xSegYsEg", + "name": "screenshot_tool", + "content": [ + { + "image": { + "format": "png", + "source": { + "bytes": "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" + } + } + } + ] + }, + "golden_response": { + "tool": "click", + "properties": { + "x": 840.65, + "y": 543.08, + "width": 85.88, + "height": 66.62, + "offset_x": 0.0, + "offset_y": 0.0 + } + } + } +] \ No newline at end of file diff --git a/tasks/eval/agents/web_agents/constants.py b/tasks/eval/agents/web_agents/constants.py new file mode 100644 index 00000000..a562b6da --- /dev/null +++ b/tasks/eval/agents/web_agents/constants.py @@ -0,0 +1,74 @@ +# Server error detection +SERVER_DOWN_ERROR = "###SERVER_ERROR###" +SERVER_ERROR_MARKERS = [SERVER_DOWN_ERROR] + +# Tool configuration +TOOL_NAME_SUFFIX = "_tool" +TOOL_NAME_MAPPINGS = { + "type": "typing", + "typing": "typing", + "text_clear": "clear-typing", + "hil": "HIL", + "wait": "waiting", + "slider": "slider-drag" +} + +# Tool type constants +TOOL_TYPE_CLICK = "click" +TOOL_TYPE_TYPING = "typing" +TOOL_TYPE_SCROLL = "scroll" + +# Property keys +PROPERTY_KEY_TOOL = "tool" + +# Retry configuration +DEFAULT_MAX_RETRIES = 3 +RETRY_KEY_PREFIX = "retry_" + +# Image scale factors +IMAGE_SCALE_FACTORS = { + "50_percent": 0.5, + "25_percent": 0.25, + "30_percent": 0.3 +} + +# Logging configuration +LOG_TIMESTAMP_FORMAT = "%Y%m%d_%H%M%S" +LOG_FILE_PREFIX = "web_agent_requests_" + +# State keys +CHAT_HISTORY_STATE_KEY = "__chat_history__" +CHAT_HISTORY_BASE_KEY = "chat_history" +MODEL_RESPONSES_KEY = "model_responses" +GOLDEN_RESPONSE_KEY = "golden_response" +CURRENT_TOOL_RESULT_KEY = "current_tool_result" +CURRENT_USER_TEXT_KEY = "current_user_text" +ORIGINAL_USER_TEXT_KEY = "original_current_user_text" +CURRENT_SCREENSHOT_KEY = "current_screenshot" + +# Retry injection configuration +RETRY_CONFIG_KEY = "retry_chat_injection" +RETRY_CONFIG_REQUIRED = "required" +RETRY_CONFIG_PROMPT_INJECTION = "retry_prompt_injection" + +# Configuration values +CONFIG_VALUE_YES = "yes" +CONFIG_VALUE_NO = "no" + +# Chat roles +CHAT_ROLE_USER = "user" +CHAT_ROLE_ASSISTANT = "assistant" +CHAT_ROLE_TOOL = "tool" + +# Content types +CONTENT_TYPE_IMAGE = "image_url" +CONTENT_TYPE_TEXT = "text" + +# Messages +TOOL_EXECUTION_MESSAGE = "Tool execution completed" +NO_TEXT_RESPONSE_PLACEHOLDER = "[No text response]" + +# Failure hints +FAILURE_HINT_TOOL_INCORRECT = "Your previous tool call '{predicted_tool}' was incorrect. Do NOT use this tool again in the retry, even with different arguments. \nIf you believe the previous tool might still be right, dismiss that belief and proceed with a different tool call." +FAILURE_HINT_PARAMS_INCORRECT = "Your previous tool call '{predicted_tool}' was correct, but had incorrect parameters. Use the same tool again but give the correct parameters in this retry." +FAILURE_HINT_RETRY_TEMPLATE = "{failure_hint} You are now retrying this step (Retry {retry_number}). Always provide a tool call in your response with the correct tool and parameters values. The latest screenshot provided is before executing your previous wrong response. So, you can directly suggest the new different correct approach on the given screenshot without considering any cleanup tool. Ensure your response progresses towards mission completion. Follow all system prompt rules and ALWAYS prioritize the user's requirements." \ No newline at end of file diff --git a/tasks/eval/agents/web_agents/graph_config.yaml b/tasks/eval/agents/web_agents/graph_config.yaml new file mode 100644 index 00000000..e9f560ea --- /dev/null +++ b/tasks/eval/agents/web_agents/graph_config.yaml @@ -0,0 +1,246 @@ +data_config: + source: + type: "disk" + file_path: "tasks/eval/agents/web_agents/chat_history_seed.json" + file_format: "json" + transformations: + - transform: sygra.processors.data_transform.AddNewFieldTransform + params: + mapping: + supported_tools: click, type, scroll, wait, resume, hil, text_clear, slider, screenshot + working_language: English + img_width: 1000 + img_height: 1000 + - transform: sygra.processors.data_transform.AddRetryFieldsTransform + params: + max_retries: 3 + initial_retry_count: 0 + original_current_user_text: + +graph_config: + graph_properties: + chat_conversation: multiturn + chat_history_window_size: 1000 + retry_chat_injection: + required: "yes" + retry_prompt_injection: "yes" + nodes: + fetch_next_action_tools: + node_type: llm + chat_history: True + pre_process: tasks.eval.agents.web_agents.task_executor.FetchNextActionPreProcessor + post_process: tasks.eval.agents.web_agents.task_executor.FetchNextActionPostProcessor + output_keys: + - model_responses + prompt: + - system: + - type: text + text: | + You are a browser automation agent that executes complex, multi-step tasks using available tools. Your actions are guided by screenshots, extracted data, navigational directions, and your action history. + + WHAT YOU RECEIVE: + 1. Screenshot of the active browser tab + 2. Previously extracted data (if any) + 3. Navigational directions for additional context (if provided) + 4. Your action history showing previous thoughts and actions taken + + CORE PRINCIPLES: + - **Think before acting**: Analyze each step carefully. Every action must move toward mission completion. + - **Tool restrictions**: Use only tools from {supported_tools}. Always invoke a tool—never respond without one. + - **Screenshot is truth**: Trust only what you see in the screenshot. Ignore assumptions about unseen browser state. + - **Stay focused**: Execute only what the mission requires. No extra actions. + - **Complete the mission**: Do not finish prematurely. Ensure all requirements are met. + + ACTION GUIDELINES: + - **Pop-ups**: Close cookie notices or pop-ups only if they block mission-critical content (close button typically top-right). + - **Advertisements**: Never interact with ad banners. Ad changes are not content changes. + - **Disabled elements**: Never interact with disabled page elements. + - **Extraction**: Never re-extract already captured content. Use the designated extraction tool. + - **Retry strategy**: If an action fails or produces no visible change in the screenshot, try a different approach. Visually examine the screenshot and provide accurate parameters for the most relevant tool. + + INTERACTION RULES: + - **Clicks**: Always provide both x and y coordinates as single numeric values. Use your vision to locate elements precisely. If previous coordinates were wrong, re-examine the screenshot for the exact position. + - **Typing with autocomplete**: Click the input field first. Type character-by-character (unless instructed otherwise) to trigger autosuggestions. Select suggestions only if they match user intent. + - **Typing without autocomplete**: Click the input field first, then type the full exact text. + - **Scrolling**: + - Specify scroll distance in pixels only (minimum double-digit values, not single-digit notches). + - Scroll only in directions where content extends beyond the viewport. + - For dropdowns/lists, scroll if visible options don't match user intent. + - **Modals**: + - To scroll within a modal, click the modal or focus an input field first. + - To close: use the top-right close button or click outside the modal. + - If scrolling produces no content change, you've reached the end. + - If no save/cancel buttons exist, close the modal to confirm changes. + - **Dropdowns**: Scroll to find options if initial visible options don't match user intent. Select the option that best matches. + - **Browser tabs**: Monitor available tabs and the active tab. Use the appropriate tool to switch tabs if needed. Detect when new tabs open. + - **Loading states**: Wait for pages to fully load or stabilize before taking the next action. + + USER CONFIRMATION REQUIRED: + Always pause and request user input or confirmation for: + 1. **Authentication**: Login pages, credentials, OTPs, MFA codes, API keys, captchas + 2. **Sensitive data**: CVV, card numbers, net banking credentials + 3. **Destructive actions**: Delete, reset, purge operations, or actions with downstream impact + 4. **Confirmation dialogs**: Delete/update confirmation modals + 5. **Errors and warnings**: System alerts, validation issues, invalid form fields, missing required data + 6. **Agreements**: Terms of service, consent forms, policy agreements + 7. **Missing inputs**: If the user hasn't provided required information, ask directly. Never assume, infer, or use placeholder/sample values. + + When requesting input, be clear, specific, and unambiguous. Proceed only after receiving the required information. + + MISSION: + {mission} + + NAVIGATIONAL DIRECTIONS: + {navigational_directions} + + SCREENSHOT SPECIFICATIONS: + The screenshot is resized to {img_width}x{img_height} pixels. All coordinates and distances must be within [0,{img_width}]x[0,{img_height}]. Visually locate elements—do not guess. + + COORDINATE REFERENCE: + - Top-left: (0, 0) + - Top-right: ({img_width}, 0) + - Bottom-left: (0, {img_height}) + - Bottom-right: ({img_width}, {img_height}) + - Center: ({img_width_50}, {img_height_50}) + - Example: Element at 25% from left, 30% from top ≈ ({img_width_25}, {img_height_30}) + - Always estimate from visual position, not descriptions + + TODAY'S DATE: {date} + + Respond only in {working_language}. No translations. + + + - user: + - type: image_url + image_url : "{current_screenshot}" + - type: text + text: "{current_user_text}" +# tool_config: + tools: + - tasks.eval.agents.web_agents.tools + tool_choice: "auto" + model: + name: eval_model + parameters: + temperature: 0.3 + + inline_evaluation: + node_type: lambda + lambda: tasks.eval.agents.web_agents.task_executor.InlineEvaluationLambda + output_keys: + - tool_match + - step_match + + evaluate_step: + node_type: lambda + lambda: tasks.eval.agents.web_agents.task_executor.RetryFlow + output_keys: + - should_continue + - final_result + + edges: + - from: START + to: fetch_next_action_tools + - from: fetch_next_action_tools + to: inline_evaluation + - from: inline_evaluation + to: evaluate_step + - from: evaluate_step + condition: tasks.eval.agents.web_agents.task_executor.ShouldContinueCondition + path_map: + END: END + fetch_next_action_tools: fetch_next_action_tools + +output_config: + output_map: + id: + from: "id" + mission: + from: "mission" + mission_id: + from: "mission_id" + turn: + from: "turn" + navigational_directions: + from: "navigational_directions" + golden_response: + from: "golden_response" + model_responses: + from: "model_responses" + tool_match: + from: "tool_match" + step_match: + from: "step_match" + + oasst_mapper: + required: "no" + type: "sft" + intermediate_writing: "yes" + +graph_post_process: + - processor: tasks.eval.agents.web_agents.task_executor.Flatten + - processor: tasks.eval.utils.MetricCollatorPostProcessor + params: + use_previous_output: True + aggregator_metrics_map: + - name: "accuracy" + params: + key: "tool" + unit_metrics_results: + - "tool_match" + - name: "precision" + params: + predicted_key: "tool" + unit_metrics_results: + - "tool_match" + - name: "recall" + params: + golden_key: "tool" + unit_metrics_results: + - "tool_match" + - name: "f1_score" + params: + predicted_key: "tool" + golden_key: "tool" + unit_metrics_results: + - "tool_match" + - name: "accuracy" + params: + key: "tool" + unit_metrics_results: + - "step_match" + - name: "precision" + params: + predicted_key: "tool" + unit_metrics_results: + - "step_match" + - name: "recall" + params: + golden_key: "tool" + unit_metrics_results: + - "step_match" + - name: "f1_score" + params: + predicted_key: "tool" + golden_key: "tool" + unit_metrics_results: + - "step_match" + - name: "pass@k" + params: + k: 3 + unit_metrics_results: + - "step_match" + - name: "pass^k" + params: + k: 3 + unit_metrics_results: + - "step_match" + - name: "step_efficiency" + params: + key: "tool" + metadata: + mission_id: "mission_id" + step_id: "turn" + retry_id: "retry_id" + unit_metrics_results: + - "step_match" \ No newline at end of file diff --git a/tasks/eval/agents/web_agents/task_executor.py b/tasks/eval/agents/web_agents/task_executor.py new file mode 100644 index 00000000..27d4e7fe --- /dev/null +++ b/tasks/eval/agents/web_agents/task_executor.py @@ -0,0 +1,639 @@ +"""Web Agent Task Executor. + +Handles request/response logging, retry logic, inline evaluation, +and post-processing for web agent tasks. +""" + +import json +import os +from copy import copy, deepcopy +from datetime import datetime +from typing import List, Dict, Any + +from sygra.core.eval.metrics.unit_metrics.action_within_bbox import ActionWithinBboxMetric +from sygra.core.eval.metrics.unit_metrics.exact_match import ExactMatchMetric +from sygra.core.eval.metrics.unit_metrics.scroll_direction import ScrollDirectionMetric +from sygra.core.eval.metrics.unit_metrics.typed_value_match import TypedValueMatchMetric +from sygra.core.graph.functions.edge_condition import EdgeCondition +from sygra.core.graph.functions.lambda_function import LambdaFunction +from sygra.core.graph.functions.node_processor import NodePreProcessor, NodePostProcessorWithState +from sygra.core.graph.graph_postprocessor import GraphPostProcessor +from sygra.core.graph.sygra_message import SygraMessage +from sygra.core.graph.sygra_state import SygraState +from sygra.logger.logger_config import logger +from sygra.utils import constants, utils + +from .constants import ( + LOG_TIMESTAMP_FORMAT, + LOG_FILE_PREFIX, + CHAT_HISTORY_STATE_KEY, + CHAT_HISTORY_BASE_KEY, + MODEL_RESPONSES_KEY, + GOLDEN_RESPONSE_KEY, + CURRENT_TOOL_RESULT_KEY, + CURRENT_USER_TEXT_KEY, + ORIGINAL_USER_TEXT_KEY, + CURRENT_SCREENSHOT_KEY, + RETRY_CONFIG_KEY, + RETRY_CONFIG_REQUIRED, + RETRY_CONFIG_PROMPT_INJECTION, + CONFIG_VALUE_YES, + CONFIG_VALUE_NO, + CHAT_ROLE_USER, + CHAT_ROLE_ASSISTANT, + CHAT_ROLE_TOOL, + CONTENT_TYPE_IMAGE, + CONTENT_TYPE_TEXT, + TOOL_EXECUTION_MESSAGE, + NO_TEXT_RESPONSE_PLACEHOLDER, + FAILURE_HINT_TOOL_INCORRECT, + FAILURE_HINT_PARAMS_INCORRECT, + FAILURE_HINT_RETRY_TEMPLATE, + RETRY_KEY_PREFIX, + DEFAULT_MAX_RETRIES, + IMAGE_SCALE_FACTORS, + TOOL_NAME_MAPPINGS, + TOOL_NAME_SUFFIX, + TOOL_TYPE_CLICK, + TOOL_TYPE_TYPING, + TOOL_TYPE_SCROLL, + PROPERTY_KEY_TOOL, + SERVER_ERROR_MARKERS +) + +# Configuration flag for keeping tool result screenshots in chat history +KEEP_TOOL_RESULT_SCREENSHOT = False + +# State keys for evaluation results +EVALUATION_TOOL_MATCH_KEY = "tool_match" +EVALUATION_STEP_MATCH_KEY = "step_match" + +# Logging messages +LOG_MESSAGE_REQUEST = "Request logged to {}" +LOG_MESSAGE_RESPONSE = "Response logged to {}" + + +class RequestResponseLogger: + """ + Comprehensive logging system for tracking exact request/response payloads. + Logs everything sent to the model and received back for debugging. + """ + + @staticmethod + def setup_logger(): + """Set up logging directory and file structure.""" + current_dir = os.path.dirname(os.path.abspath(__file__)) + log_dir = os.path.join(current_dir, 'logs') + os.makedirs(log_dir, exist_ok=True) + + timestamp = datetime.now().strftime(LOG_TIMESTAMP_FORMAT) + log_file = os.path.join(log_dir, f'{LOG_FILE_PREFIX}{timestamp}.json') + + return log_file + + @staticmethod + def _write_log_entry(log_entry: dict, log_type: str): + """Write a log entry to the log file. + + Args: + log_entry: Log entry dictionary to write + log_type: Type of log (REQUEST or RESPONSE) for logging message + """ + log_file = RequestResponseLogger.setup_logger() + + try: + logs = [] + if os.path.exists(log_file): + with open(log_file, 'r') as f: + logs = json.load(f) + + logs.append(log_entry) + + with open(log_file, 'w') as f: + json.dump(logs, f, indent=2, default=str) + + log_message = LOG_MESSAGE_REQUEST if log_type == "REQUEST" else LOG_MESSAGE_RESPONSE + logger.info(log_message.format(log_file)) + except Exception as e: + logger.error(f"Failed to log {log_type.lower()}: {e}") + + @staticmethod + def log_request(request_payload: dict, step_number: int): + """Log the exact request payload sent to the model.""" + log_entry = { + "type": "REQUEST", + "timestamp": datetime.now().isoformat(), + "retry_number": step_number, + "payload": request_payload + } + RequestResponseLogger._write_log_entry(log_entry, "REQUEST") + + @staticmethod + def log_response(response_data: dict, step_number: int): + """Log the exact response received from the model.""" + log_entry = { + "type": "RESPONSE", + "timestamp": datetime.now().isoformat(), + "retry_number": step_number, + "response": response_data + } + RequestResponseLogger._write_log_entry(log_entry, "RESPONSE") + + @staticmethod + def is_server_error(response_text: str, tool_calls: List[Dict[str, Any]] = None) -> bool: + """ + Detect if the response contains a server/infrastructure error. + Server errors are transient issues that might be resolved in subsequent retries. + + Args: + response_text: Model's text response + tool_calls: Model's tool calls (unused, kept for backward compatibility) + + Returns: + bool: True if this is a server error, False otherwise + """ + if not response_text: + return False + + response_lower = response_text.lower() + for marker in SERVER_ERROR_MARKERS: + if marker.lower() in response_lower: + logger.warning(f"Server error detected: {marker}") + return True + + return False + + +class FetchNextActionPreProcessor(NodePreProcessor): + """ + Pre-processor that prepares state before LLM call. + Checks previous retry status and modifies chat_history if previous retry failed. + + Reads retry configuration from graph_properties: + - retry_chat_injection.required: "yes" or "no" - whether to inject retry context + - retry_chat_injection.retry_prompt_injection: "yes" or "no" - whether to modify prompt + """ + + @classmethod + def retry_failure_and_chat_injection(cls, state: SygraState, curr_retry: int, + retry_prompt_injection: str) -> SygraState: + """Handle retry failure and inject into chat history. + + Args: + state: Current GraspState + curr_retry: Current retry number + retry_prompt_injection: "yes" or "no" - whether to modify the user prompt with failure hints + """ + + if curr_retry == 0: + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + logger.info( + f"{cls.__name__}: Retry 0 - Initialized {CHAT_HISTORY_STATE_KEY} with {len(state[CHAT_HISTORY_STATE_KEY])} messages") + return state + + prev_retry_key = f"{RETRY_KEY_PREFIX}{curr_retry - 1}" + retry_responses = state.get(MODEL_RESPONSES_KEY, {}) + + if prev_retry_key not in retry_responses: + logger.warning(f"{cls.__name__}: Previous retry data not found for {prev_retry_key}") + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + if ORIGINAL_USER_TEXT_KEY in state: + state[CURRENT_USER_TEXT_KEY] = state[ORIGINAL_USER_TEXT_KEY] + return state + + prev_retry_data = retry_responses[prev_retry_key] + + # Get evaluation result from state (populated by InlineEvaluationLambda) + step_match_results = state.get(EVALUATION_STEP_MATCH_KEY, {}) + evaluation_result = step_match_results.get(prev_retry_key) + + if evaluation_result is None: + logger.warning( + f"{cls.__name__}: No evaluation result found in state for retry {curr_retry - 1}") + prev_failed = True + else: + prev_failed = not evaluation_result.get('correct', False) + + if not prev_failed: + logger.info( + f"{cls.__name__}: Retry {curr_retry} - Previous retry succeeded, using base chat_history") + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + return state + + # Previous retry FAILED - check if it's a valid failure worth learning from or some Server error + logger.info( + f"{cls.__name__}: Retry {curr_retry} - Previous retry FAILED, checking failure type") + + prev_response_text = prev_retry_data.get('text_response', '') + prev_tool_calls = prev_retry_data.get('tool_calls', []) + + # Check for errors using error detection utils + has_server_error = RequestResponseLogger.is_server_error(prev_response_text, prev_tool_calls) + + if has_server_error: + logger.info(f"{cls.__name__}: Previous retry was a server error. " + f"Not appending to chat history. Using previous chat_history instead.") + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + return state + + # Valid failure (wrong tool or wrong parameters) - append to history for learning + logger.info(f"{cls.__name__}: Previous retry was a valid failure (model error). " + f"Building failure context for chat history.") + + modified_history = copy(state[CHAT_HISTORY_BASE_KEY]) + + user_content = [] + + if KEEP_TOOL_RESULT_SCREENSHOT: + user_content.append({ + "type": CONTENT_TYPE_IMAGE, + "image_url": {"url": state.get(CURRENT_SCREENSHOT_KEY, "")} + }) + + user_content.append({ + "type": CONTENT_TYPE_TEXT, + "text": state.get(CURRENT_USER_TEXT_KEY, "") + }) + + user_turn = { + "role": CHAT_ROLE_USER, + "content": user_content + } + + modified_history.append(user_turn) + + assistant_turn = { + "role": CHAT_ROLE_ASSISTANT, + "content": prev_response_text if prev_response_text else NO_TEXT_RESPONSE_PLACEHOLDER + } + + if prev_tool_calls: + assistant_turn["tool_calls"] = prev_tool_calls + + modified_history.append(assistant_turn) + + if prev_tool_calls: + for tool_call in prev_tool_calls: + tool_turn = { + "role": CHAT_ROLE_TOOL, + "tool_call_id": tool_call.get("id", ""), + "content": TOOL_EXECUTION_MESSAGE + } + modified_history.append(tool_turn) + logger.info(f"{cls.__name__}: Added {len(prev_tool_calls)} tool turn(s) after assistant") + + logger.info( + f"{cls.__name__}: Appended valid failed retry context. History length: {len(modified_history)}") + + state[CHAT_HISTORY_BASE_KEY] = copy(modified_history) + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + + if retry_prompt_injection == CONFIG_VALUE_YES: + # Get evaluation result to determine failure type + tool_match_results = state.get(EVALUATION_TOOL_MATCH_KEY, {}) + + prev_tool_eval = tool_match_results.get(prev_retry_key) + + # Determine if tool was correct + tool_correct = prev_tool_eval.get('correct', False) if prev_tool_eval else False + + predicted_tool = cls._extract_predicted_tool(prev_tool_calls) + + failure_hint = (FAILURE_HINT_TOOL_INCORRECT if not tool_correct + else FAILURE_HINT_PARAMS_INCORRECT).format(predicted_tool=predicted_tool) + + if ORIGINAL_USER_TEXT_KEY not in state: + state[ORIGINAL_USER_TEXT_KEY] = state.get(CURRENT_USER_TEXT_KEY, "") + + state[CURRENT_USER_TEXT_KEY] = FAILURE_HINT_RETRY_TEMPLATE.format( + failure_hint=failure_hint, + retry_number=curr_retry + ) + logger.info(f"{cls.__name__}: Modified current_user_text with failure hint") + else: + logger.info( + f"{cls.__name__}: retry_prompt_injection is '{retry_prompt_injection}', keeping original prompt") + + return state + + @classmethod + def _extract_predicted_tool(cls, tool_calls: List[Dict[str, Any]]) -> str: + """Extract and normalize predicted tool name from tool calls. + + Args: + tool_calls: List of tool call dictionaries + + Returns: + Normalized tool name + """ + if not tool_calls: + return 'unknown' + + predicted_tool_raw = tool_calls[0].get('function', {}).get('name', 'unknown') + predicted_base_tool = predicted_tool_raw.replace(TOOL_NAME_SUFFIX, '') + return TOOL_NAME_MAPPINGS.get(predicted_base_tool, predicted_base_tool) + + @classmethod + def _setup_image_dimensions(cls, state: SygraState) -> None: + """Setup scaled image dimensions in state. + + Args: + state: Current state to update with image dimensions + """ + img_width = state.get("img_width", 0) + img_height = state.get("img_height", 0) + + state["img_width_50"] = img_width * IMAGE_SCALE_FACTORS["50_percent"] + state["img_height_50"] = img_height * IMAGE_SCALE_FACTORS["50_percent"] + state["img_width_25"] = img_width * IMAGE_SCALE_FACTORS["25_percent"] + state["img_height_30"] = img_height * IMAGE_SCALE_FACTORS["30_percent"] + + @classmethod + def _extract_screenshot(cls, state: SygraState) -> None: + """Extract screenshot from tool result and store in state. + + Args: + state: Current state to update with screenshot + """ + current_tool_result = state.get(CURRENT_TOOL_RESULT_KEY, {}) + content = current_tool_result.get("content", []) + + if len(content) == 1 and content[0].get("image"): + image_data = content[0]["image"] + img_fmt = image_data.get("format") + img_content = image_data.get("source", {}).get("bytes") + if img_fmt and img_content: + state[CURRENT_SCREENSHOT_KEY] = f"data:image/{img_fmt};base64,{img_content}" + + @classmethod + def apply(cls, state: SygraState) -> SygraState: + """Prepare state for LLM call, handling retry failure context.""" + logger.info(f"{cls.__name__}: Setting up for LLM call") + state[CHAT_HISTORY_STATE_KEY] = copy(state[CHAT_HISTORY_BASE_KEY]) + curr_retry = state.get('curr_retries', 0) + + cls._setup_image_dimensions(state) + cls._extract_screenshot(state) + + task_name = utils.current_task + graph_properties = utils.get_graph_properties(task_name) + retry_config = graph_properties.get(RETRY_CONFIG_KEY, {}) + retry_injection_required = retry_config.get(RETRY_CONFIG_REQUIRED, CONFIG_VALUE_NO) + + if retry_injection_required == CONFIG_VALUE_YES: + retry_prompt_injection = retry_config.get(RETRY_CONFIG_PROMPT_INJECTION, CONFIG_VALUE_NO) + state = cls.retry_failure_and_chat_injection(state, curr_retry, retry_prompt_injection) + logger.info(f"{cls.__name__}: Retry chat injection applied (prompt_injection={retry_prompt_injection})") + else: + logger.info(f"{cls.__name__}: Retry chat injection disabled by graph_properties") + + return state + + +class FetchNextActionPostProcessor(NodePostProcessorWithState): + """ + Post-processor that handles model response. + Stores current retry's model response for use by next retry's PreProcessor. + """ + + @classmethod + def apply(cls, resp: SygraMessage, state: SygraState) -> SygraState: + """Process and store model's response.""" + logger.info(f"{cls.__name__}: Processing model response") + + retry_number = state["curr_retries"] + RequestResponseLogger.log_response(resp.message, retry_number) + + response_text = resp.message.content if hasattr(resp.message, 'content') else str(resp.message) + tool_calls = state.get("tool_calls", []) + + response_dict = { + 'text_response': response_text, + 'tool_calls': tool_calls + } + + if MODEL_RESPONSES_KEY not in state: + state[MODEL_RESPONSES_KEY] = {} + + retry_key = f"{RETRY_KEY_PREFIX}{retry_number}" + state[MODEL_RESPONSES_KEY][retry_key] = response_dict + + chat_history_len = len(state.get(CHAT_HISTORY_STATE_KEY, [])) + logger.info(f"{cls.__name__}: Stored {retry_key} response (chat history length: {chat_history_len})") + + return state + + +class InlineEvaluationLambda(LambdaFunction): + """ + Lambda node for inline evaluation of retry attempts. + Evaluates the retry's success/failure and stores results in state. + """ + + @classmethod + def apply(cls, lambda_node_dict: dict, state: SygraState) -> SygraState: + """ + Evaluate the previous retry attempt and store results in state. + + Args: + lambda_node_dict: Configuration dictionary + state: Current state + + Returns: + Updated state with evaluation results + """ + retry_number = state.get('curr_retries', 0) + + # Get previous retry data + retry_key = f"{RETRY_KEY_PREFIX}{retry_number}" + retry_responses = state.get(MODEL_RESPONSES_KEY, {}) + + if retry_key not in retry_responses: + logger.warning(f"{cls.__name__}: No data found for {retry_key}") + return state + + retry_data = retry_responses[retry_key] + + logger.info(f"{cls.__name__}: Starting evaluation for retry {retry_number}") + golden_response = state.get(GOLDEN_RESPONSE_KEY, {}) + golden_tool = golden_response.get('tool', 'unknown') + golden_params = golden_response.get('properties', {}) + golden_params[PROPERTY_KEY_TOOL] = golden_tool + + tool_calls = retry_data.get('tool_calls', []) + if not tool_calls: + logger.warning(f"{cls.__name__}: No tool calls found for retry {retry_number}") + return state + + tool_call = tool_calls[0] + if not isinstance(tool_call, dict): + logger.warning(f"{cls.__name__}: Invalid tool call format: {tool_call}") + return state + + predicted_tool = cls._extract_and_normalize_tool(tool_call) + predicted_params = cls._parse_tool_arguments(tool_call, predicted_tool) + + # Evaluate tool match (tool identification) + validator = ExactMatchMetric(key=PROPERTY_KEY_TOOL) + tool_results = validator.evaluate( + golden=[{PROPERTY_KEY_TOOL: golden_tool}], + predicted=[{PROPERTY_KEY_TOOL: predicted_tool}] + ) + if EVALUATION_TOOL_MATCH_KEY not in state: + state[EVALUATION_TOOL_MATCH_KEY] = {} + state[EVALUATION_TOOL_MATCH_KEY][retry_key] = tool_results[0].to_dict() + + # Evaluate step match (tool + parameters) + step_results = None + if predicted_tool == TOOL_TYPE_CLICK: + metric = ActionWithinBboxMetric() + step_results = metric.evaluate( + golden=[golden_params], + predicted=[predicted_params], + ) + elif predicted_tool == TOOL_TYPE_TYPING: + metric = TypedValueMatchMetric() + step_results = metric.evaluate( + golden=[golden_params], + predicted=[predicted_params], + ) + elif predicted_tool == TOOL_TYPE_SCROLL: + metric = ScrollDirectionMetric() + step_results = metric.evaluate( + golden=[golden_params], + predicted=[predicted_params], + ) + else: + logger.warning(f"{cls.__name__}: Unknown tool type for parameter validation: {predicted_tool}") + # For unknown tools, use tool match result as step match + step_results = tool_results + + if EVALUATION_STEP_MATCH_KEY not in state: + state[EVALUATION_STEP_MATCH_KEY] = {} + if step_results: + state[EVALUATION_STEP_MATCH_KEY][retry_key] = step_results[0].to_dict() + + return state + + @classmethod + def _extract_and_normalize_tool(cls, tool_call: Dict[str, Any]) -> str: + """Extract and normalize tool name from tool call. + + Args: + tool_call: Tool call dictionary + + Returns: + Normalized tool name + """ + predicted_tool_raw = tool_call.get('function', {}).get('name', '') + predicted_base_tool = predicted_tool_raw.replace(TOOL_NAME_SUFFIX, '') + return TOOL_NAME_MAPPINGS.get(predicted_base_tool, predicted_base_tool) + + @classmethod + def _parse_tool_arguments(cls, tool_call: Dict[str, Any], tool_name: str) -> Dict[str, Any]: + """Parse and prepare tool arguments. + + Args: + tool_call: Tool call dictionary + tool_name: Normalized tool name + + Returns: + Parsed arguments dictionary with tool name + """ + predicted_params = tool_call.get('function', {}).get('arguments', {}) + + if isinstance(predicted_params, str): + try: + predicted_params = json.loads(predicted_params) + except (json.JSONDecodeError, TypeError): + logger.warning(f"{cls.__name__}: Failed to parse arguments as JSON: {predicted_params}") + predicted_params = {} + + predicted_params[PROPERTY_KEY_TOOL] = tool_name + return predicted_params + + +class RetryFlow(LambdaFunction): + """ + Determines whether to continue the flow or end based on retry count. + """ + + @classmethod + def apply(cls, lambda_node_dict: dict, state: SygraState) -> SygraState: + """Validate current state and determine next action.""" + curr_retry = state.get("curr_retries", 0) + 1 + max_retries = state.get("max_retries", DEFAULT_MAX_RETRIES) + mission_id = state.get("id") + + state["curr_retries"] = curr_retry + state["should_continue"] = curr_retry < max_retries + + if state["should_continue"]: + logger.info(f"{cls.__name__}: Mission {mission_id} completed retry {curr_retry}, continuing") + else: + logger.info(f"{cls.__name__}: Mission {mission_id} reached max retries ({max_retries})") + + return state + + +class ShouldContinueCondition(EdgeCondition): + """ + Edge condition for determining whether to continue the flow. + """ + + @classmethod + def apply(cls, state: SygraState) -> str: + should_continue = state.get('should_continue', False) + + if should_continue: + logger.info(f"{cls.__name__}: Continuing to fetch_next_action_tools") + return 'fetch_next_action_tools' + else: + logger.info(f"{cls.__name__}: Ending flow") + return constants.SYGRA_END + + +class Flatten(GraphPostProcessor): + """Flattens nested retry structure so each retry becomes a separate record.""" + + def process(self, data: list, metadata: dict) -> list: + """Process data by flattening retry structure. + + Args: + data: List of mission records with nested retry data + metadata: Additional metadata + + Returns: + Flattened list where each retry is a separate record + """ + + flattened = [] + + for mission in data: + base_fields = { + "id": mission.get("id"), + "mission_id": mission.get("mission_id"), + "turn": mission.get("turn"), + "mission": mission.get("mission"), + "navigational_directions": mission.get("navigational_directions"), + "golden_response": mission.get("golden_response"), + } + + model_responses = mission.get(MODEL_RESPONSES_KEY, {}) + tool_matches = mission.get(EVALUATION_TOOL_MATCH_KEY, {}) + step_matches = mission.get(EVALUATION_STEP_MATCH_KEY, {}) + + if not model_responses: + continue + + for retry_id, model_response in model_responses.items(): + row = deepcopy(base_fields) + + row["retry_id"] = retry_id + row["model_response"] = model_response + row["tool_match"] = tool_matches.get(retry_id) + row["step_match"] = step_matches.get(retry_id) + + flattened.append(row) + + return flattened diff --git a/tasks/eval/agents/web_agents/tools.py b/tasks/eval/agents/web_agents/tools.py new file mode 100644 index 00000000..093dfc15 --- /dev/null +++ b/tasks/eval/agents/web_agents/tools.py @@ -0,0 +1,116 @@ +from langchain_core.tools import tool + +from sygra.logger.logger_config import logger + +@tool +def screenshot_tool(take_screenshot: bool): + """Take a screenshot to see the current state of the page. + + Args: + take_screenshot: Whether or not to take a screenshot + """ + logger.info(f"Taking screenshot: {take_screenshot}") + return + +@tool +def click_tool(x: float, y: float): + """Click on an element on the page using x and y coordinates. + + Args: + x: The x coordinate of the element to click on. + y: The y coordinate of the element to click on. + """ + logger.info(f"Clicking at coordinates: x={x}, y={y}") + return + + +@tool +def type_tool(x: float, y: float, text: str): + """Simulates a type action on the screen using coordinates of the mouse and the text to be typed. + + Args: + x: The x coordinate of the click. + y: The y coordinate of the click. + text: The text to be typed. + """ + logger.info(f"Typing at coordinates: x={x}, y={y} with text='{text}'") + return + + +@tool +def typing_tool(text: str): + """Type text into an element on the page (coordinate-free version). + + Args: + text: The text to be typed. + """ + logger.info(f"Typing text: '{text}'") + return + + +@tool +def scroll_tool(direction: str, amount: float): + """Scroll in a chosen direction by a specified amount. + + Args: + direction: The direction to scroll in. + amount: The amount of pixels to scroll by. + """ + logger.info(f"Scrolling direction='{direction}', amount={amount}") + return + + +@tool +def wait_tool(time: float): + """Wait for a specified amount of time in milliseconds. + + Args: + time: The amount of time to wait in milliseconds. + """ + logger.info(f"Waiting for time(ms)={time}") + return + + +@tool +def resume_tool(resume: bool): + """Resume the current task after waiting or user input. + + Args: + resume: Whether or not to resume the task execution. + """ + logger.info(f"Resuming task: {resume}") + return + + +@tool +def hil_tool(wait_for_human: bool): + """Human in the loop. Wait for human input. + + Args: + wait_for_human: Whether or not to wait for the human to intervene. + """ + logger.info(f"Wait for human in loop: {wait_for_human}") + return + + +@tool +def text_clear_tool(clear_text: bool): + """Clears all the text from the element before typing new text. + + Args: + clear_text: Whether or not to clear the text from the element. + """ + logger.info(f"Clearing text: {clear_text}") + return + + +@tool +def slider_tool(direction: str, amount: float): + """Move a slider in a chosen direction by a specified amount. + + Args: + direction: The direction to move the slider. + amount: The amount of pixels to move the slider by. + """ + logger.info(f"Moving slider direction='{direction}', amount={amount}") + return \ No newline at end of file diff --git a/tasks/eval/classification/simpleqa/graph_config.yaml b/tasks/eval/classification/simpleqa/graph_config.yaml index 5a0227cc..16672c36 100644 --- a/tasks/eval/classification/simpleqa/graph_config.yaml +++ b/tasks/eval/classification/simpleqa/graph_config.yaml @@ -56,7 +56,7 @@ graph_config: params: key: "text" output_keys: - - exact_match_result + - exact_match edges: - from: START to: generate_taxonomy @@ -75,8 +75,8 @@ output_config: from: "topic" predicted_topic: from: "predicted_topic" - exact_match_result: - from: "exact_match_result" + exact_match: + from: "exact_match" graph_post_process: - processor: tasks.eval.utils.MetricCollatorPostProcessor @@ -86,20 +86,20 @@ graph_post_process: params: key: "text" unit_metrics_results: - - "exact_match_result" + - "exact_match" - name: "precision" params: predicted_key: "text" unit_metrics_results: - - "exact_match_result" + - "exact_match" - name: "recall" params: golden_key: "text" unit_metrics_results: - - "exact_match_result" + - "exact_match" - name: "f1_score" params: predicted_key: "text" golden_key: "text" unit_metrics_results: - - "exact_match_result" + - "exact_match" diff --git a/tasks/eval/question_answering/simpleqa/graph_config.yaml b/tasks/eval/question_answering/simpleqa/graph_config.yaml index 9a28d3ed..ef7b845d 100644 --- a/tasks/eval/question_answering/simpleqa/graph_config.yaml +++ b/tasks/eval/question_answering/simpleqa/graph_config.yaml @@ -44,8 +44,13 @@ graph_config: - name: "exact_match" params: key: "text" + - name: "fuzzy_match" + params: + key: "text" + threshold: 0.8 output_keys: - - exact_match_result + - exact_match + - fuzzy_match edges: - from: START to: predict_answer @@ -64,8 +69,10 @@ output_config: from: "answer" predicted_answer: from: "predicted_answer" - exact_match_result: - from: "exact_match_result" + exact_match: + from: "exact_match" + fuzzy_match: + from: "fuzzy_match" graph_post_process: @@ -76,4 +83,9 @@ graph_post_process: params: key: "text" unit_metrics_results: - - "exact_match_result" \ No newline at end of file + - "exact_match" + - name: "accuracy" + params: + key: "text" + unit_metrics_results: + - "fuzzy_match" \ No newline at end of file diff --git a/tasks/eval/utils.py b/tasks/eval/utils.py index c2a3ab2f..5458084f 100644 --- a/tasks/eval/utils.py +++ b/tasks/eval/utils.py @@ -1,4 +1,5 @@ import json +from datetime import datetime """ Utilities for evaluation tasks. @@ -68,7 +69,7 @@ def apply(lambda_node_dict: dict, state: SygraState) -> SygraState: validator = UnitMetricRegistry.get_metric(unit_metric_name, **unit_metric_params) results = validator.evaluate(golden=golden_topic, predicted=predicted_answer) if results: - state[unit_metric_name + "_result"] = results[0].to_dict() + state[unit_metric_name] = results[0].to_dict() return state @@ -84,10 +85,9 @@ class MetricCollatorPostProcessor(GraphPostProcessor): def __init__( self, aggregator_metrics_map: Optional[list[dict[str, Any]]] = None, - unit_metrics_results: str = "text" + **kwargs: Any ): self.aggregator_metrics_map = aggregator_metrics_map or [] - self.unit_metrics_results = unit_metrics_results def process(self, data: list, metadata: dict) -> list: """ @@ -119,10 +119,8 @@ def process(self, data: list, metadata: dict) -> list: for aggregator_metric in self.aggregator_metrics_map: aggregator_metric_name = aggregator_metric["name"] aggregator_metric_params = aggregator_metric.get("params", {}) + unit_metrics_field = aggregator_metric.get("unit_metrics_results", "") - unit_metrics_field = aggregator_metric.get( - "unit_metrics_results", self.unit_metrics_results - ) if isinstance(unit_metrics_field, list): unit_metrics_field = unit_metrics_field[0] if unit_metrics_field else "" @@ -132,22 +130,39 @@ def process(self, data: list, metadata: dict) -> list: f"Available columns: {list(df.columns)}" ) - unit_metrics_results = ( - df[unit_metrics_field] - .apply(lambda d: UnitMetricResult(**d) if isinstance(d, dict) else d) - .tolist() - ) + # Build unit metric results with enriched metadata + metadata_mapping = aggregator_metric.get("metadata", {}) + + unit_metrics_results = [] + for idx, row in df.iterrows(): + unit_result_data = row[unit_metrics_field] + + if isinstance(unit_result_data, dict): + # Enrich metadata with fields specified in graph config + if metadata_mapping: + if "metadata" not in unit_result_data: + unit_result_data["metadata"] = {} + + # Generic mapping: store source values with metadata keys + for metadata_key, source_field in metadata_mapping.items(): + source_value = row.get(source_field, "unknown") + unit_result_data["metadata"][metadata_key] = source_value + + unit_metrics_results.append(UnitMetricResult(**unit_result_data)) + elif isinstance(unit_result_data, UnitMetricResult): + unit_metrics_results.append(unit_result_data) metric = AggregatorMetricRegistry.get_metric( aggregator_metric_name, **aggregator_metric_params ) metric_result = metric.calculate(unit_metrics_results) - results[aggregator_metric_name] = metric_result + results[unit_metrics_field + "-" + aggregator_metric_name] = metric_result return [{ "evaluation_summary": { "total_records": len(data), + "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "status": "success" }, "results": results diff --git a/tests/core/eval/metrics/aggregator_metrics/test_pass_at_k.py b/tests/core/eval/metrics/aggregator_metrics/test_pass_at_k.py index 0a446e05..e78d5424 100644 --- a/tests/core/eval/metrics/aggregator_metrics/test_pass_at_k.py +++ b/tests/core/eval/metrics/aggregator_metrics/test_pass_at_k.py @@ -32,8 +32,8 @@ def test_calculate_empty_results(self): results = [] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.0 + assert "pass@1" in output + assert output["pass@1"] == 0.0 def test_calculate_all_correct(self): """Test calculate when all predictions are correct""" @@ -60,8 +60,8 @@ def test_calculate_all_correct(self): ] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 1.0 + assert "pass@1" in output + assert output["pass@1"] == 1.0 def test_calculate_all_incorrect(self): """Test calculate when all predictions are incorrect""" @@ -88,8 +88,8 @@ def test_calculate_all_incorrect(self): ] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.0 + assert "pass@1" in output + assert output["pass@1"] == 0.0 def test_calculate_mixed_results(self): """Test calculate with mixed correct/incorrect predictions""" @@ -122,8 +122,8 @@ def test_calculate_mixed_results(self): ] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.5 # 2 correct out of 4 + assert "pass@1" in output + assert output["pass@1"] == 0.5 # 2 correct out of 4 def test_calculate_single_correct_result(self): """Test calculate with single correct result""" @@ -138,8 +138,8 @@ def test_calculate_single_correct_result(self): ] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 1.0 + assert "pass@1" in output + assert output["pass@1"] == 1.0 def test_calculate_single_incorrect_result(self): """Test calculate with single incorrect result""" @@ -154,8 +154,8 @@ def test_calculate_single_incorrect_result(self): ] output = metric.calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.0 + assert "pass@1" in output + assert output["pass@1"] == 0.0 def test_calculate_various_pass_at_k_values(self): """Test calculate with various pass@k percentages""" @@ -168,10 +168,11 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassAtKMetric(k=1).calculate(results) - assert output["pass@k"] == 0.75 + assert output["pass@1"] == 0.75 output = PassAtKMetric(k=2).calculate(results) - assert output["pass@k"] == 1.0 + assert output["pass@1"] == 0.75 + assert output["pass@2"] == 1.0 # 60% pass@k (3 out of 5) results = [ @@ -182,13 +183,16 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassAtKMetric(k=1).calculate(results) - assert output["pass@k"] == 0.6 + assert output["pass@1"] == 0.6 output = PassAtKMetric(k=2).calculate(results) - assert output["pass@k"] == 0.9 + assert output["pass@1"] == 0.6 + assert output["pass@2"] == 0.9 output = PassAtKMetric(k=3).calculate(results) - assert output["pass@k"] == 1.0 + assert output["pass@1"] == 0.6 + assert output["pass@2"] == 0.9 + assert output["pass@3"] == 1.0 # 33.33% pass@k (1 out of 3) results = [ @@ -197,13 +201,16 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassAtKMetric(k=1).calculate(results) - assert output["pass@k"] == pytest.approx(0.333, rel=1e-2) + assert output["pass@1"] == pytest.approx(0.333, rel=1e-2) output = PassAtKMetric(k=2).calculate(results) - assert output["pass@k"] == pytest.approx(0.666, rel=1e-2) + assert output["pass@1"] == pytest.approx(0.333, rel=1e-2) + assert output["pass@2"] == pytest.approx(0.666, rel=1e-2) output = PassAtKMetric(k=3).calculate(results) - assert output["pass@k"] == 1.0 + assert output["pass@1"] == pytest.approx(0.333, rel=1e-2) + assert output["pass@2"] == pytest.approx(0.666, rel=1e-2) + assert output["pass@3"] == 1.0 def test_calculate_with_complex_metadata(self): """Test calculate with complex metadata in results""" @@ -230,12 +237,14 @@ def test_calculate_with_complex_metadata(self): ), ] output = PassAtKMetric(k=1).calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.5 + assert "pass@1" in output + assert output["pass@1"] == 0.5 output = PassAtKMetric(k=2).calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 1.0 + assert "pass@1" in output + assert "pass@2" in output + assert output["pass@1"] == 0.5 + assert output["pass@2"] == 1.0 def test_calculate_with_different_data_types(self): """Test calculate with different data types in golden/predicted""" @@ -247,9 +256,11 @@ def test_calculate_with_different_data_types(self): UnitMetricResult(correct=False, golden={"value": [1, 2]}, predicted={"value": [1, 3]}), ] output = PassAtKMetric(k=1).calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 0.75 + assert "pass@1" in output + assert output["pass@1"] == 0.75 output = PassAtKMetric(k=2).calculate(results) - assert "pass@k" in output - assert output["pass@k"] == 1.0 + assert "pass@1" in output + assert "pass@2" in output + assert output["pass@1"] == 0.75 + assert output["pass@2"] == 1.0 diff --git a/tests/core/eval/metrics/aggregator_metrics/test_pass_power_k.py b/tests/core/eval/metrics/aggregator_metrics/test_pass_power_k.py index ff8a836d..052cc0f1 100644 --- a/tests/core/eval/metrics/aggregator_metrics/test_pass_power_k.py +++ b/tests/core/eval/metrics/aggregator_metrics/test_pass_power_k.py @@ -32,8 +32,10 @@ def test_calculate_empty_results(self): results = [] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.0 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.0 + assert output["pass^1"] == 0.0 def test_calculate_all_correct(self): """Test calculate when all predictions are correct""" @@ -60,8 +62,10 @@ def test_calculate_all_correct(self): ] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 1.0 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 1.0 + assert output["pass^1"] == 1.0 def test_calculate_all_incorrect(self): """Test calculate when all predictions are incorrect""" @@ -88,8 +92,10 @@ def test_calculate_all_incorrect(self): ] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.0 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.0 + assert output["pass^1"] == 0.0 def test_calculate_mixed_results(self): """Test calculate with mixed correct/incorrect predictions""" @@ -122,8 +128,10 @@ def test_calculate_mixed_results(self): ] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.5 # 2 correct out of 4 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.5 # 2 correct out of 4 + assert output["pass^1"] == 0.5 def test_calculate_single_correct_result(self): """Test calculate with single correct result""" @@ -138,8 +146,10 @@ def test_calculate_single_correct_result(self): ] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 1.0 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 1.0 + assert output["pass^1"] == 1.0 def test_calculate_single_incorrect_result(self): """Test calculate with single incorrect result""" @@ -154,8 +164,10 @@ def test_calculate_single_incorrect_result(self): ] output = metric.calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.0 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.0 + assert output["pass^1"] == 0.0 def test_calculate_various_pass_at_k_values(self): """Test calculate with various pass^k percentages""" @@ -168,13 +180,19 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassPowerKMetric(k=1).calculate(results) - assert output["pass^k"] == 0.75 + assert output["success_rate"] == 0.75 + assert output["pass^1"] == 0.75 output = PassPowerKMetric(k=2).calculate(results) - assert output["pass^k"] == 0.5625 + assert output["success_rate"] == 0.75 + assert output["pass^1"] == 0.75 + assert output["pass^2"] == 0.5625 output = PassPowerKMetric(k=3).calculate(results) - assert output["pass^k"] == 0.421875 + assert output["success_rate"] == 0.75 + assert output["pass^1"] == 0.75 + assert output["pass^2"] == 0.5625 + assert output["pass^3"] == 0.421875 # 60% pass^k (3 out of 5) results = [ @@ -185,10 +203,13 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassPowerKMetric(k=1).calculate(results) - assert output["pass^k"] == 0.6 + assert output["success_rate"] == 0.6 + assert output["pass^1"] == 0.6 output = PassPowerKMetric(k=2).calculate(results) - assert output["pass^k"] == 0.36 + assert output["success_rate"] == 0.6 + assert output["pass^1"] == 0.6 + assert output["pass^2"] == 0.36 # 33.33% pass^k (1 out of 3) results = [ @@ -197,10 +218,13 @@ def test_calculate_various_pass_at_k_values(self): UnitMetricResult(correct=False, golden={}, predicted={}), ] output = PassPowerKMetric(k=1).calculate(results) - assert output["pass^k"] == pytest.approx(0.333, rel=1e-2) + assert output["success_rate"] == pytest.approx(0.333, rel=1e-2) + assert output["pass^1"] == pytest.approx(0.333, rel=1e-2) output = PassPowerKMetric(k=2).calculate(results) - assert output["pass^k"] == pytest.approx(0.111, rel=1e-2) + assert output["success_rate"] == pytest.approx(0.333, rel=1e-2) + assert output["pass^1"] == pytest.approx(0.333, rel=1e-2) + assert output["pass^2"] == pytest.approx(0.111, rel=1e-2) def test_calculate_with_complex_metadata(self): """Test calculate with complex metadata in results""" @@ -227,12 +251,18 @@ def test_calculate_with_complex_metadata(self): ), ] output = PassPowerKMetric(k=1).calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.5 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.5 + assert output["pass^1"] == 0.5 output = PassPowerKMetric(k=2).calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.25 + assert "success_rate" in output + assert "pass^1" in output + assert "pass^2" in output + assert output["success_rate"] == 0.5 + assert output["pass^1"] == 0.5 + assert output["pass^2"] == 0.25 def test_calculate_with_different_data_types(self): """Test calculate with different data types in golden/predicted""" @@ -244,9 +274,15 @@ def test_calculate_with_different_data_types(self): UnitMetricResult(correct=False, golden={"value": [1, 2]}, predicted={"value": [1, 3]}), ] output = PassPowerKMetric(k=1).calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.75 + assert "success_rate" in output + assert "pass^1" in output + assert output["success_rate"] == 0.75 + assert output["pass^1"] == 0.75 output = PassPowerKMetric(k=2).calculate(results) - assert "pass^k" in output - assert output["pass^k"] == 0.5625 + assert "success_rate" in output + assert "pass^1" in output + assert "pass^2" in output + assert output["success_rate"] == 0.75 + assert output["pass^1"] == 0.75 + assert output["pass^2"] == 0.5625 diff --git a/tests/core/eval/metrics/aggregator_metrics/test_step_efficiency.py b/tests/core/eval/metrics/aggregator_metrics/test_step_efficiency.py new file mode 100644 index 00000000..f50efbcf --- /dev/null +++ b/tests/core/eval/metrics/aggregator_metrics/test_step_efficiency.py @@ -0,0 +1,325 @@ +""" +Unit tests for StepEfficiencyMetric +Tests the step efficiency aggregator metric that calculates efficiency based on retry attempts. +""" + +import os +import sys + +sys.path.insert( + 0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "..")) +) + +import pytest + +from sygra.core.eval.metrics.aggregator_metrics.step_efficiency import StepEfficiencyMetric +from sygra.core.eval.metrics.unit_metrics.unit_metric_result import UnitMetricResult + + +class TestStepEfficiencyMetric: + """Test suite for StepEfficiencyMetric""" + + def test_default_penalty(self): + """Test metric with default penalty (0.2)""" + metric = StepEfficiencyMetric() + assert metric.penalty_per_retry == 0.2 + + def test_custom_penalty(self): + """Test metric with custom penalty""" + metric = StepEfficiencyMetric(penalty_per_retry=0.3) + assert metric.penalty_per_retry == 0.3 + + def test_invalid_penalty_negative(self): + """Test that negative penalty raises error""" + with pytest.raises(ValueError): + StepEfficiencyMetric(penalty_per_retry=-0.1) + + def test_invalid_penalty_greater_than_one(self): + """Test that penalty > 1 raises error""" + with pytest.raises(ValueError): + StepEfficiencyMetric(penalty_per_retry=1.5) + + def test_empty_results(self): + """Test with empty results list""" + metric = StepEfficiencyMetric() + result = metric.calculate([]) + assert result["step_efficiency"] == 0.0 + assert result["total_steps"] == 0 + assert result["first_attempt_correct"] == 0 + assert result["retry_correct"] == 0 + assert result["never_correct"] == 0 + + def test_all_first_attempt_correct(self): + """Test when all steps are correct on first attempt (no penalty)""" + metric = StepEfficiencyMetric() + results = [ + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "B"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s2", "retry_number": 0}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "C"}, + predicted={"answer": "C"}, + metadata={"mission_id": "m1", "step_id": "s3", "retry_number": 0}, + ), + ] + + result = metric.calculate(results) + assert result["step_efficiency"] == 1.0 + assert result["total_steps"] == 3 + assert result["first_attempt_correct"] == 3 + assert result["retry_correct"] == 0 + assert result["never_correct"] == 0 + assert result["avg_retries_when_correct"] == 0.0 + + def test_second_attempt_correct(self): + """Test when answer is correct on second attempt (retry_number=1)""" + metric = StepEfficiencyMetric(penalty_per_retry=0.2) + results = [ + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 1}, + ), + ] + + result = metric.calculate(results) + assert result["step_efficiency"] == 0.8 + assert result["total_steps"] == 1 + assert result["first_attempt_correct"] == 0 + assert result["retry_correct"] == 1 + assert result["never_correct"] == 0 + assert result["avg_retries_when_correct"] == 1.0 + + def test_third_attempt_correct(self): + """Test when answer is correct on third attempt (retry_number=2)""" + metric = StepEfficiencyMetric(penalty_per_retry=0.2) + results = [ + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "C"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 1}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 2}, + ), + ] + + result = metric.calculate(results) + assert result["step_efficiency"] == 0.6 + assert result["total_steps"] == 1 + assert result["first_attempt_correct"] == 0 + assert result["retry_correct"] == 1 + assert result["never_correct"] == 0 + assert result["avg_retries_when_correct"] == 2.0 + + def test_never_correct(self): + """Test when no correct answer is found (full penalty)""" + metric = StepEfficiencyMetric() + results = [ + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "C"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 1}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "D"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 2}, + ), + ] + + result = metric.calculate(results) + assert result["step_efficiency"] == 0.0 + assert result["total_steps"] == 1 + assert result["first_attempt_correct"] == 0 + assert result["retry_correct"] == 0 + assert result["never_correct"] == 1 + assert result["avg_retries_when_correct"] == 0.0 + + def test_mixed_steps(self): + """Test with mixed results across multiple steps""" + metric = StepEfficiencyMetric(penalty_per_retry=0.2) + results = [ + # Step 1: correct on first attempt + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + # Step 2: correct on second attempt + UnitMetricResult( + correct=False, + golden={"answer": "B"}, + predicted={"answer": "X"}, + metadata={"mission_id": "m1", "step_id": "s2", "retry_number": 0}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "B"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s2", "retry_number": 1}, + ), + # Step 3: never correct + UnitMetricResult( + correct=False, + golden={"answer": "C"}, + predicted={"answer": "Y"}, + metadata={"mission_id": "m1", "step_id": "s3", "retry_number": 0}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "C"}, + predicted={"answer": "Z"}, + metadata={"mission_id": "m1", "step_id": "s3", "retry_number": 1}, + ), + ] + + result = metric.calculate(results) + # Step 1: 1.0, Step 2: 0.8, Step 3: 0.0 -> Average: 1.8/3 = 0.6 + assert result["step_efficiency"] == pytest.approx(0.6, rel=1e-6) + assert result["total_steps"] == 3 + assert result["first_attempt_correct"] == 1 + assert result["retry_correct"] == 1 + assert result["never_correct"] == 1 + assert result["avg_retries_when_correct"] == 0.5 + + def test_multiple_missions(self): + """Test with multiple missions and steps""" + metric = StepEfficiencyMetric(penalty_per_retry=0.25) + results = [ + # Mission 1, Step 1: first attempt correct + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + # Mission 2, Step 1: second attempt correct + UnitMetricResult( + correct=False, + golden={"answer": "B"}, + predicted={"answer": "X"}, + metadata={"mission_id": "m2", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "B"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m2", "step_id": "s1", "retry_number": 1}, + ), + ] + + result = metric.calculate(results) + # Step m1_s1: 1.0, Step m2_s1: 0.75 -> Average: 1.75/2 = 0.875 + assert result["step_efficiency"] == pytest.approx(0.875, rel=1e-6) + assert result["total_steps"] == 2 + assert result["first_attempt_correct"] == 1 + assert result["retry_correct"] == 1 + + def test_efficiency_cannot_go_negative(self): + """Test that efficiency is clamped at 0.0 even with many retries""" + metric = StepEfficiencyMetric(penalty_per_retry=0.2) + results = [ + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "B"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 0}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "C"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 1}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "D"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 2}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "E"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 3}, + ), + UnitMetricResult( + correct=False, + golden={"answer": "A"}, + predicted={"answer": "F"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 4}, + ), + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1", "retry_number": 10}, + ), + ] + + result = metric.calculate(results) + # 1.0 - 10*0.2 = -1.0, but should be clamped to 0.0 + assert result["step_efficiency"] == 0.0 + assert result["retry_correct"] == 1 + assert result["never_correct"] == 0 + + def test_metadata_name(self): + """Test metric metadata""" + metric = StepEfficiencyMetric() + assert metric.get_metric_name() == "step_efficiency" + assert metric.metadata.display_name == "Step Efficiency" + assert metric.metadata.higher_is_better is True + assert metric.metadata.range == (0.0, 1.0) + + def test_missing_retry_number_defaults_to_zero(self): + """Test that missing retry_number in metadata defaults to 0""" + metric = StepEfficiencyMetric() + results = [ + UnitMetricResult( + correct=True, + golden={"answer": "A"}, + predicted={"answer": "A"}, + metadata={"mission_id": "m1", "step_id": "s1"}, + ), + ] + + result = metric.calculate(results) + assert result["step_efficiency"] == 1.0 + assert result["first_attempt_correct"] == 1