AI Tool Access
Network & Troubleshooting Guide

NETWORK / REQUEST PATH

Request paths and region detection

Break access down into verifiable steps

An AI conversation doesn't involve the browser exchanging text continuously with a single server. Page assets, authentication, conversation APIs, file uploads and content delivery may use different domains. The app may also rely on backend services to keep a task running. A successful homepage load only confirms that the requests needed to fetch that page completed at that moment. It doesn't prove that the generation API, model permissions or upload channel are working. When troubleshooting, note exactly where things stop: can't open the page, can't sign in, no response after submitting, or the answer stops partway through. Each symptom points to a different place to check.

From your device, requests typically pass through the app, system network settings, client routing, your local access network, international routes and the destination service. A browser extension may only affect the browser, while some apps ignore the system proxy. Enabling tunnel mode also doesn't guarantee that every environment inherits the same DNS resolution and routing. Test from the app where the problem occurs rather than relying on results from another browser. If the browser works but the command line doesn't, first look for differences in network configuration between processes.

Your egress IP is only one regional signal

Services can usually see the source IP of a connection and use their own IP databases to estimate its region. Those databases may be out of date, and different services may return different results. A network test showing one region doesn't mean every AI platform will see the same one. Account region, workspace rules, billing details and organization administrator settings may also affect eligibility. If you see a region warning, check the target platform's official availability information rather than attributing every issue to the route name.

A stable egress route makes the network environment easier to understand throughout a session. Stable doesn't mean dedicated or permanent: shared egress IPs may also carry traffic from other users. An extra verification prompt for a particular IP doesn't, by itself, prove your local setup is wrong. Note the route selected in the client, the detected egress region and the error text. Keep the same setup while you retest, then decide whether to switch. Changing regions repeatedly adds variables and makes the original evidence less useful.

Check DNS, connectivity and TLS separately

DNS resolution maps a hostname to an address, connection setup lets two endpoints communicate, and the TLS handshake verifies identity and negotiates protection for the transfer. A DNS failure and a certificate error are different problems and shouldn't be fixed the same way. First confirm that your system clock is correct. Then check whether DNS returns a result, whether a connection can be established and whether the certificate hostname matches. If your organization requires a private certificate, install it using the administrator's instructions. Don't turn off certificate verification to make a security error appear to go away.

Where DNS resolution happens can affect the result too. Some proxy configurations resolve hostnames locally; others send the hostname to the proxy to resolve. The behavior depends on the app and client settings. If your browser and development tool resolve different addresses, first check whether they use different resolution methods, then check their caches. You can check your current egress IP on the network test page, but that result only reflects the browser making the request. It can't replace checks from a terminal, container or remote development host.

MeteVPN covers 120+ countries / 190+ routes. See the routes page for available options. Coverage describes network resources; it doesn't guarantee access to any third-party tool. Military-grade encryption describes this service's security offering, but doesn't change a target platform's regional policies, account permissions or content rules. Check transport connectivity, account eligibility and feature access separately.

APPLICATION / BOUNDARIES

What makes AI tools available

Distinguish access points from features

ChatGPT, Claude and Gemini all offer web-based chat, but specific features may depend on account type, region, workspace and product settings. Web chat, file analysis, voice, image features and developer APIs aren't a single set of permissions. Being able to chat by text doesn't mean you can use the API under the same brand. Seeing a feature advertised doesn't mean it's available to your account. First confirm the product and how you're accessing it, then check the relevant eligibility requirements in its official help documentation.

Troubleshoot ChatGPT web sessions and developer APIs separately. For the web app, focus on the sign-in session, browser state and interaction requests. The API also involves projects, keys, model access and billing status. Claude likewise has separate web, API and third-party integration entry points. Similar model names don't mean requests go to the same endpoint. If you use a third-party integration, check its documentation to confirm the service provider and which account owns the credentials before changing settings for the wrong platform.

Gemini's consumer-facing app and developer platform also have different account and regional requirements. Being signed in to an account in your browser doesn't mean your developer project, organization policies or API authorization are ready. Organization-managed accounts may have restrictions on generative AI tools, data sharing or third-party apps. If you see a permissions warning, check your signed-in identity and workspace first, then check your egress route. Switching routes can't replace administrator approval or make an ineligible account eligible.

Products with the same name and editor integrations

Copilot is a name that needs context. A consumer chat app and GitHub Copilot for developers aren't interchangeable in licensing, organization management or client integration. Sign-in from a developer tool may open an external browser and then return the authorization result to the editor. If the browser says authorization succeeded but the editor remains signed out, check whether the callback can return to the original app, whether the editor uses a different proxy, and whether the organization allows the extension.

For Midjourney, break the issue down by its current official access point: sign-in, task submission, task processing and loading result assets. If the server is already processing a task, closing the page locally may not cancel it. An incomplete image may simply mean its asset domain isn't reachable over the same path. Check task history to see whether the server received the request before troubleshooting the local preview. Repeated submissions without checking can create duplicate tasks; a missing result on screen doesn't prove the server never processed the request.

Cursor brings editing, indexing, chat and model requests into one workflow, but each part may use a different network path. Editor updates, account authorization, codebase indexing and model generation can fail independently. If you've configured your own API key, check whether the selected model uses it and whether requests originate locally or from the product's servers. With remote development, the editor UI and extension runtime may be on different machines, so check both the local and remote environments.

State availability conclusions precisely

Useful notes say, “This account completed this action in this environment,” rather than claiming a tool is always available. Record the access point, feature, point of failure and egress route so you can compare them if something changes. This guide doesn't guarantee ongoing access to any particular tool, model or regional feature. For a quick overview of access considerations, see the AI tools guide. If product policies change, follow the platform's current official guidance.

IDENTITY / SESSION

Accounts, sign-in and session risk controls

Keep network service accounts separate from tool accounts

MeteVPN doesn't require an email address; you can create an account with a username and password. This requirement applies only to MeteVPN and doesn't mean AI platforms use the same rules. The target tool sets its own account details, sign-in methods, regional eligibility and recovery process. Before getting started, check the official sign-in page to see what information is required, provide only what's necessary and store recovery materials securely. Never enter your MeteVPN credentials in an AI tool or give AI platform credentials to a network service client.

A password manager is useful for storing unique passwords for each site. Treat subscription links as access credentials: anyone who has one may be able to import routes or use account resources. Don't post them in public forums, group chats or code repositories. Before sharing a screenshot for help, check the address bar, subscription section in the client and any QR codes. A QR code may contain the full link, so obscuring the visible text while leaving the code intact doesn't protect it. Check request headers and automatically collected environment details before sharing logs, too.

Keep the sign-in context consistent

Keep your device, browser settings and egress region consistent throughout a sign-in flow. Authentication often spans multiple pages and may involve redirects, callbacks and cross-site storage. Switching browsers, closing the original tab or changing egress midway may prevent the service from reliably associating later steps with the original session. Complete the flow in the original window and follow the platform's official steps if it asks for verification. Don't automate repeated attempts or create accounts in bulk to test routes.

Browser privacy settings and extensions can affect authentication. Strict cross-site storage restrictions, content-blocking rules or script modifications can sometimes cause repeated redirects on an authorization page. To troubleshoot, try a separate browser profile for comparison and temporarily adjust only settings related to the target site, rather than disabling protections across the board. If sign-in works in the new profile, check the original profile's cache, extensions or storage policies. Use a separate profile to isolate the issue, not to evade platform account rules.

Before clearing site data, make sure your password and recovery materials are available, and check for unsaved conversations or drafts. Clear data for the affected site first rather than routinely deleting all browsing history. When you're done, return to the official address and confirm whether you're signed in to a personal or organization account. If your browser has multiple identities, the authorization page may select the wrong one by default, making a permissions issue look like a network problem. Signing out of the wrong identity and completing a fresh sign-in is usually more useful than repeatedly changing routes.

Verification, restrictions and suspensions are different

An additional verification step asks you to confirm something. An access restriction means a particular action isn't currently allowed. Account suspension is a clearer account status. They may look similar but call for different responses. Save the full error text and check for official guidance, an appeal option or a notice from your organization administrator. If the platform says your account is restricted, stop treating it as a client connectivity issue. Changing egress won't restore permissions, and you shouldn't disguise your environment to get around restrictions.

A shared egress IP's history, unusual request patterns, frequent sign-ins and account behavior may all factor into a platform's risk controls, but users rarely have access to the full decision process. A single verification prompt doesn't prove a route is permanently blocked, and no IP type can guarantee that a platform will trust it. The practical approach is to avoid unnecessary changes, use supported clients, follow platform rules and submit an official appeal when needed. Claims that a network service can guarantee an unrestricted account aren't adequately supported.

When using public Wi-Fi or a shared computer, check whether passwords are being saved automatically, whether any sessions are still signed in and whether sensitive files remain in the downloads folder. Sign out and remove materials you don't need when you're done. For more on protecting credentials, see the VPN security guide for beginners. An encrypted connection can't replace endpoint security or prevent an authorized browser extension from reading page content.

TRANSPORT / STREAMING

Persistent connections and streaming responses

Separate a delayed first token from a mid-response drop

Streaming delivers generated content to the client as it's produced instead of waiting for the entire answer to finish. Web apps often read an ongoing HTTP response, while some interactive features may use other persistent connection mechanisms. Not every AI conversation uses WebSockets. To troubleshoot, first check whether the request was sent, when the response began arriving and when the connection ended. No text after submitting and a response that starts but stops midway usually call for different troubleshooting paths.

A delayed first token may be caused by connection setup, server queueing, tool calls or model processing. If output has started and then stops, check for network changes, read timeouts, intermediary network devices and client state. These are leads to investigate, not definitive conclusions based on symptoms alone. Compare task history, response status and client logs. The target service may also have experienced an interruption; one failed request doesn't prove that your local route is persistently unstable.

Why a regular webpage can load while a stream still drops

A short web request finishes quickly, and its connection only needs to stay open until the file is retrieved. A generation request may stream over a longer period or show no visible output while the model is processing. Idle timeouts in an intermediate proxy, corporate gateway or the app itself may close the connection while it's waiting. Some intermediaries also buffer responses and forward them only after collecting a chunk, so answers appear all at once. A fast page download doesn't show that the streaming path is configured correctly.

Browser developer tools can help distinguish a connection issue from a display issue. Find the relevant request and check whether it's still in progress, whether response data continues to arrive and how it ends. Inspect only sessions you're authorized to access, and don't publish complete network traces. Exported network logs often contain session identifiers, request content and authorization details. Analyze them locally or share them with a trusted support channel only after thorough redaction.

Device sleep, switching networks, system power-saving settings and client reconnections can all interrupt persistent connections. Try reproducing the issue while keeping the device awake and network connection unchanged, then compare with your usual setup. If it only happens after locking the screen or switching networks, check the system and app background policies first. Don't change routes, proxy modes, browser state and power settings all at once, or you won't know which change affected the result.

Attachments, generated results and retries

File uploads, image previews and generated result downloads may use separate asset domains. If text chat works but attachments fail, check the upload path separately and make sure the file format, content and size meet the platform's requirements. Don't upload confidential work files or sensitive personal materials to test the network; use a simple file with no private information. If the platform reports a content restriction or format error, address the file requirements rather than changing routes again.

A streaming interruption doesn't necessarily mean the task failed. Check the conversation or task history for a result before continuing generation or submitting again. In development, account for the possibility that duplicate requests could incur duplicate charges or trigger external actions. Test persistent connection quality with the actual task rather than relying on a single download test. For an overview of route types and their limitations, see the international routes guide. Labels such as IEPL, relay or direct don't guarantee that generation will succeed for every tool.

API / REQUEST CONTROL

API calls versus web access

Check API identity and product billing first

Web products and APIs are usually separate access points, with potentially different accounts, project permissions, quotas and billing. Being able to select a model in the web app doesn't mean the API provides access to the same model. A network subscription doesn't cover a third-party platform's model fees. Before making a call, check the project's settings, model ID, API endpoint and credential permissions in the platform's official console. Even if a third-party gateway uses a similar format, check its service terms separately rather than assuming the original platform's regional and data-handling policies apply.

Store API keys only in controlled runtime environments. Never put them in frontend code, public repositories, screenshots or commit history. Environment variables are useful for passing keys to a process at startup, but debug output or error collection systems can expose them. Configure logs to redact authorization headers and sensitive fields by default, keeping only what's needed to troubleshoot, such as request IDs, model names, elapsed time by stage and error categories. If a credential is exposed, revoke and rotate it first, then remove published copies. Deleting only the current file isn't enough.

Understand timeouts by stage

A connection timeout limits how long connection setup can take. A read timeout controls how long the client waits for response data. A total deadline caps the entire task. SDKs may define these options differently, and defaults can vary. Some read timeouts measure the gap between incoming data; others include additional stages. Check the documentation for the library you're using rather than copying a setting from one example to every project. In streaming mode, a long total duration may be expected; a prolonged lack of data is more likely to trigger a read timeout.

Retry policies should depend on the reason for failure. A temporary connection error may warrant a limited retry with backoff and jitter to avoid many clients retrying at once. Authentication errors, regional eligibility issues, model access restrictions and billing problems generally require a configuration change; repeating the request won't fix them. If you hit a rate limit, follow the response's retry guidance and reduce request frequency or concurrency. Adding retries blindly only increases load, error logs and potential costs.

A request timeout doesn't prove the server didn't process the request. The connection may have dropped after the server accepted the task, leaving the client without a result. If the API supports idempotency or task lookup, use those features as documented. If it doesn't, track task state at the application level and assess the risk of duplicate execution. For agent workflows that send messages, modify files or call external tools, don't treat every network error as safe to retry. Check for side effects before deciding how to recover.

Test connectivity without sending credentials

The command below tests connection to the target domain, the TLS handshake and receipt of a response. It doesn't fetch a model list, send a key or confirm account or regional eligibility. Run it in the same terminal environment as the app, and verify the target domain against the official documentation first. An HTTP error page may still mean the transport completed. If the command exits with an error, use the error text to distinguish DNS, connectivity and certificate issues.

curl --verbose --output /dev/null https://api.openai.com/

In Windows PowerShell, use curl.exe to explicitly call the system's curl and avoid differences caused by command aliases. Don't paste detailed logs into a public support ticket, especially after testing a request with an authorization header. To test a business API, use your own controlled environment and the official SDK documentation, and share only redacted error categories. Once the transport test succeeds, check credentials, project, model and request parameters one at a time.

Concurrency, connection pools and bandwidth budgets

Developer applications should also account for connection reuse and concurrency limits. Creating a new client for every request adds handshake overhead, while uncontrolled concurrency can exhaust local connection resources or trigger platform limits. Reuse clients as recommended by the SDK, and handle queue lengths, request cancellation and cleanup after errors explicitly. Long answers, images, attachments and retries all affect data usage; input text length alone isn't enough to estimate it. For selection guidance, see AI API network recommendations, but base your final decision on your own tasks.

RUNTIME / CONFIGURATION

Command line, IDE and CI configuration

Test settings in the process that uses them

System proxies, terminal environment variables, app-level settings and tunnel routing are different configuration layers. A browser reaching a site doesn't mean terminal programs will inherit the system proxy. Some tools read environment variables, some rely on runtime proxy options, and others need a proxy configured in the app itself. First check which network library the program uses and how the tool officially supports proxy settings, then choose the right layer to change. Avoid stacking multiple forwarding mechanisms, which can create nested proxies or hard-to-explain routes.

For programs that support proxy environment variables, use HTTPS_PROXY, HTTP_PROXY or ALL_PROXY to specify a route, subject to the tool's documentation. The protocol in the variable name and the protocol used by the proxy address aren't the same thing: an HTTP proxy can still be used to access an HTTPS destination. Copy the actual local listening address from the client. Don't guess the port or assume another device has the same listener settings.

In terminals that support the syntax, you can set variables for the current session only. The example below interactively reads the proxy address shown by your client, so the real address or credentials aren't hard-coded in the script. This only demonstrates setting the environment; you still need to verify that the app uses these variables. If the proxy address contains credentials, don't record your screen, share the terminal or print the variable. Clear any settings you no longer need from the current session after testing.

read -r -p "Enter the local proxy address shown by the client: " METE_LOCAL_PROXY
export HTTPS_PROXY="$METE_LOCAL_PROXY"
export HTTP_PROXY="$METE_LOCAL_PROXY"

# Start the tool you want to test from this terminal.

unset HTTPS_PROXY HTTP_PROXY METE_LOCAL_PROXY

NO_PROXY and process inheritance

NO_PROXY is commonly used to bypass the proxy for local services or specific internal addresses, but libraries differ in how they interpret domain suffixes, wildcard patterns and IP ranges. Start with the smallest necessary list and add only destinations that genuinely need a direct connection. An overly broad rule may send API requests that should use the proxy directly instead. Environment variables are also inherited by child processes: an editor that's already running won't automatically pick up changes made in a different terminal. Restart it or update its settings according to the tool's instructions.

In an IDE, the extension host, integrated terminal, background language service and web views may run in separate processes. If GitHub Copilot or Cursor has connection issues, first identify whether the failure involves authorization, a model request or asset loading, then check the relevant process settings. An IDE proxy setting doesn't guarantee that a plugin's separate runtime inherits it. Likewise, a successful test in the integrated terminal doesn't prove that requests from the graphical interface use the same path. Use the tool's own diagnostic logs to gather evidence where possible.

Local addresses differ in containers and on remote hosts

A loopback address in a container points to the container itself. On a remote development host, a local address points to the remote host, not your personal computer running the client. Copying your desktop's local proxy address into a container or remote environment often results in a connection refusal. Check the network topology and permitted connection methods before setting up a controlled forward or host access path. Don't expose a proxy listener on the public internet for convenience. If access across devices is necessary, restrict its source and follow your network administrator's requirements.

CI tasks run in the environment where their runner is located and generally don't inherit the client state of your development computer. Successful dependency downloads don't prove that a model API is reachable, since software registries and AI services may use different networks. Check the runtime region, organization egress policy, proxy environment and credential injection location within the job. Store sensitive variables in the repository's protected settings. For jobs from untrusted branches or external contributions, restrict access to secrets and paid API calls.

Document network settings and application configuration separately. Record variable names, where settings apply, how the process starts and how to verify the setup; never record real credentials. A configuration that can be verified in a fresh terminal or runner is suitable for team documentation. For client installation and subscription setup, follow the guide. This section covers how different runtime environments use and verify network paths after the client connects.

DIAGNOSIS / EVIDENCE

Error categories and troubleshooting order

Start with the original error, not a settings change

A useful troubleshooting record preserves the original error instead of just saying “it won't open.” Note the tool, action, error text, access point and network environment, then describe the expected and actual results. Time information helps match local logs with platform incidents, but there's no need to share your complete usage history. If the interface provides a request ID, keep it for official support. Don't send conversation content, authorization headers, subscription links and personal details together. Focused evidence makes it easier to distinguish a network issue from an account issue.

Check the local basics first: confirm your system can access the internet, the clock is correct, the client is connected and the selected route is the one you intended. Then test the target domain from the app that actually fails instead of running an unrelated speed test. If regular webpages also fail, fix the underlying network connection first. If only one AI tool fails, move on to checking the domain, session and permissions. Don't keep changing model parameters while the basic connection is broken; that mixes two separate problems.

Narrow down the issue by layer

If a domain can't be resolved, check DNS settings and whether the app uses its own resolution path. A connection refusal may mean the destination isn't listening, the proxy address is wrong or a local forwarder isn't running. A connection timeout may involve routing, network policies or a destination that isn't responding. For certificate errors, check the hostname, clock and trust chain. These issues arise before the application request, so refreshing the account page won't fix them. Record the error category before testing changes to avoid unnecessary sign-in attempts.

An HTTP response means a server or intermediary processed the request, but you still need to confirm whether it came from the target service or a gateway. For authentication failures, check credentials and identity first. For permission or region warnings, check eligibility and policy; for rate limits, check quotas and request patterns. For server errors, consult platform status and retry guidance. Don't draw a final conclusion from the status code alone: platforms may use different formats for similar issues. Read the response body alongside the official documentation.

Change one variable at a time

To check whether egress is involved, keep the device, app, account and test action the same. Change only to another route that meets the target platform's regional requirements, then see whether the error changes. If it stays exactly the same, check other layers. If it improves, that only shows the network paths differed in this comparison; it doesn't prove the original route is permanently broken. Record the before-and-after state rather than relying on a vague impression that one setup “seems faster” after several changes.

To check the browser environment, keep the network and account unchanged and repeat the same action in a separate profile. To check the app proxy, compare an explicitly configured proxy with the default settings in the same terminal. Use simple test materials with no private information, avoiding complex plugins, external tool calls or large attachments that add variables. Different prompts may take different amounts of processing time, so don't mistake a change in task complexity for a change in network quality.

When to stop retrying and ask for help

If the platform explicitly says an account is restricted, a region is unsupported or access is blocked by your organization, contact the relevant official support channel instead of switching networks again. For MeteVPN connection or subscription issues, check the Help Center first. If you need further assistance, submit redacted details through the user panel support ticket. Describe the checks you've completed, what reproduces the issue and what works. A screenshot of an error without context isn't enough.

After resolving an issue, record the conclusion and where it applies. “The extension wasn't inheriting the proxy; updating its settings fixed it” is more useful than “restarting helped.” If the cause isn't confirmed, say it was temporarily resolved rather than presenting a guess as fact. For recurring issues, compare common factors such as runtime environment, network changes, task type and session stage. The goal is a reproducible cause-and-effect relationship, not an ever-growing collection of conflicting settings.

OPERATIONS / ROUTINE

Route selection and ongoing maintenance

Establish a baseline for each task

For regular AI tool use, establish a repeatable set of checks instead of looking for the “best route” every day. Choose a region supported by the target platform, then use your usual tasks to test sign-in, a short conversation, a long response and attachment handling. Developers should also test requests with their actual SDK and deployment environment. Record which access points and actions work, which are restricted and whether organization policies apply. Only tests that match your real workflow can guide daily use; route names and one-off speed results can't replace them.

IEPL dedicated lines, relay routes and direct connections describe how network paths are organized; they don't directly indicate whether an AI platform trusts an IP address. A route's transport path may suit your current access network without meeting a platform's eligibility requirements. Track route quality and application eligibility separately, and choose a stable path that complies with the platform's rules. To compare route types, see the descriptions on the routes page. Don't treat a technical label as a guarantee of access to every app.

Keep plan details separate from app fees

MeteVPN monthly plans are ¥9.9/month for 60GB, ¥18/month for 250GB and ¥28/month for 500GB. Data resets monthly on your activation date; mid-cycle upgrades are prorated for the remaining days. Data add-ons are ¥158/300GB, ¥358/1000GB and ¥658/3000GB, available until used and never expiring. Before choosing, consider file uploads, generated images, development dependencies and everyday browsing rather than estimating all your needs from a single text conversation. See the plans page for full details.

This service supports unlimited devices and works with Windows / macOS / iOS / Android / Linux. Payment options are Alipay / WeChat / USDT, with a 60-day no-questions-asked refund policy. Unlimited devices describes this service's device policy; it doesn't mean third-party AI accounts allow unrestricted sharing or simultaneous use. Check network subscription costs separately from the target platform's memberships, APIs and other fees. Teams should also follow organizational data-handling and account licensing requirements rather than using personal network settings in place of internal approval.

Maintain clients, subscriptions and credentials

Get the client and subscription through the user panel. For platforms other than iOS, sign in to download the client. On iOS, access to the download page requires an active plan; get your subscription after signing in. Use the links in the panel to install and import. Don't download substitute installers from unfamiliar posts or put real subscription URLs in team repositories. Save any necessary settings before updating the client, then check that routing and proxy settings still work as expected.

When rotating a subscription link or API key, check every place it is used, including local clients, remote hosts, automated jobs and team secret managers. Updating only your desktop settings may leave background jobs using old credentials. Deleting exposed content doesn't remove historical copies; revoke and rotate the credential first. Credential maintenance is separate from route changes, and restoring connectivity doesn't eliminate the need to secure exposed credentials. Periodically check for permissions and environment variables you no longer need.

Leave maintainable handoff notes for your team

Team documentation should say who handles network settings, who manages AI platform access and who is authorized to manage costs and quotas. Use dummy values in configuration examples and store real secrets in a controlled system. Document tool entry points, where they run, the scope of proxy settings and how to escalate issues, but not members' private conversation content. After changing devices or migrating a runner, repeat the same checklist, paying particular attention to address boundaries between containers, local terminals and remote services. This helps catch hidden direct connections or routes that no longer work.

AI platforms may change their supported regions, model access points and administration rules. Check official guidance during maintenance and update internal documentation. One successful test reflects only the environment at that moment; it isn't a long-term guarantee. A failed test should be traced by stage rather than treated as proof that the entire service is unavailable. To follow the setup from the beginning, return to the quick-start guide. For more on developer API requirements, see AI API network recommendations. Keeping network, identity, permissions and app settings separate makes future troubleshooting clearer.