First things first — you’ll need Cursor IDE.

If you don’t have it yet, go ahead and install it (full setup guide is right here).

Once Cursor is ready, set up your project.

If you’re new to the FTO Indicator API, don’t worry — that same guide also covers how to prep your environment so you’re good to go.

Introduction

Want to build your own indicator from scratch? You’re in the right place.

This tutorial walks you through creating a custom indicator using Cursor IDE.

Don’t worry if it sounds complicated — we’ll go step by step, with screenshots and examples. By the end, you’ll have your very own indicator running in FTO, powered by Cursor’s AI.

Cursor has a Rules feature — basically a way to teach the AI how you want it to behave when generating code.

Think of it as house rules for a guest: “shoes off, fridge is fair game, don’t touch the cat.”

By setting up rules that explain how indicators work in FTO, you’re giving Cursor the context it needs to create consistent, accurate code. No more random guesses — just well-informed suggestions.

To set global rules:

1. Click the Settings icon (see Picture #1)

1. From the Settings menu, click on Rules (see Picture #2).

This is where you’ll drop in the custom guidelines that will teach Cursor how to behave when working with your indicators.

Think of this as setting the ground rules before starting a board game — once everyone knows the rules, things run smoother (and there’s less arguing).\

1. In the User Rules field (see Picture #3), paste in the contents of the file called Rules.txt.

That’s your playbook — the set of instructions that teaches Cursor how to “think” when working with indicators in FTO.

Pro tip: It’s like giving your AI a cheat sheet before the test. The more detail you put in here, the less Cursor will bother you later with questions.

If strategies are the brain and hands of trading, indicators are the eyes.They don’t open or close trades for you, but they help you see the market more clearly — drawing lines, showing averages, or highlighting trends. Think of them as your personal set of night-vision goggles: they light up what’s happening on the chart so you can decide what to do next (or let your strategy decide).In short:

• Strategies = decision-makers (they trade)

• Indicators = signal-givers (they show the picture)

With indicators, you can track momentum, spot entry points, or just make your charts look way cooler. Ready to add some trading super-vision? Let’s dive in!\

Overview

Welcome to the documentation for creating custom indicators in Forex Tester Online (FTO).

This guide is designed to help developers and strategy testers understand the structure, lifecycle, and capabilities of custom scripts written for FTO. You’ll learn how to set up your environment, build your own indicators, and access key platform features via the available API.

📌 What You’ll Find Here

• Get started with setting up your development environment and creating your first indicator using a simple Moving Average example.

• Understand the lifecycle of an indicator through core functions like Init, Calculate, Done, and more.

• Learn how to create and manage visible buffers to display your indicator’s values on the chart.

👨‍💻 Who is This For?

This documentation is for:

• Developers building and debugging trading indicators

• Algorithmic traders backtesting and optimizing their strategies

• Power users looking to customize and extend FTO’s capabilities

🚀 Ready to Begin?

Start with the guide and move on to the to see how it all works in action.

f you’ve already run the npm run build command and everything went smoothly, you should now have a file called my-indicator-project.js sitting inside your dist folder. That’s the one we’re going to upload.

Open FTO, head over to your project, and in the Indicators tab hit Upload Indicator. Then just drag-and-drop your .js file into the upload area or select it manually (see Picture #1 and Picture #2).

Pro tip: Treat this file like your golden ticket — once it’s in FTO, you’ll finally get to see your indicator in action.

After uploading, your indicator will show up in the “My Indicators” dropdown menu (see Picture #3).

From here, just pick it, hit Apply, and watch it come alive on your chart.

Pro tip: If you don’t see it right away, double-check that you uploaded the .js file from your dist folder — that’s the only one FTO recognizes.

Remember the documentation we uploaded back in Step 3? Now it’s time to make Cursor use it like a pro.

Here’s how:

• Switch Cursor to Ask Mode (it’s the one for questions and answers).

• In your request, type @ and choose Docs from the drop-down menu (see Picture #1).

This tells Cursor, “Hey, use the official FTO indicator docs for this answer.”

It’s like giving your AI a quick shot of espresso before it writes code — smarter, faster, and right on point.

From that drop-down menu, choose FTO Indicator documentation — the same one we uploaded back in Step 3 (see Picture #2).

This basically tells Cursor, “Hey, use the official playbook for this answer.” It’s like handing your AI the cheat sheet before an exam — fewer mistakes, better results.

Cursor needs to know which file to use for your indicator. You can simply drag and drop it straight from the Explorer panel (on the left) into the chat window, or use the @ menu, scroll down to Files & Folders, and select it from the list (see Picture #3). It’s like pointing Cursor to the right canvas before asking it to paint — now it knows exactly where to put the code.

Once you’ve selected the docs and the right file, Cursor has everything it needs to work its magic. From here, it’s just you, the AI, and some clean indicator-building fun. Time to let the code flow!

This guide shows you how to prepare your environment so you can start writing your own custom indicator for FTO.

To use the custom indicator API, you’ll first need an example to work from. Don’t worry, we’ve got you covered — you can either browse a few ready-made examples here, or just grab the suggested starter file below. Think of it as your “Hello World” for indicators.

Why start with an example?

Jumping into custom indicators from scratch can feel like walking into a movie halfway through — you’ll miss the setup.

That’s why we suggest starting with a ready-made example:

• You see the basic structure in action

• You avoid silly mistakes on the first steps

• You can tweak and play instead of reinventing the wheel

It’s faster, safer, and way more fun. Once you’re comfortable, you can always build your own indicator logic from scratch.

Open and Set Things Up

Open the example project in Cursor (or any IDE you like — but honestly, Cursor makes life easier).

Next, click the little terminal icon (see Picture #1) — it’s that black box where all the behind-the-scenes magic happens.

Now run:

Once the dependencies are in place, it’s time to build your project.

Pop open your terminal (still in that same black box of magic) and run:

This will compile your indicator into a nice, ready-to-use .js file.

Think of it as baking the dough you just mixed — after this step, you’ll actually have bread instead of just flour and water.

If everything goes well, you should see a fresh build appear in your dist folder. That’s your indicator, ready for action!

After building, you’ll see a fresh file named my-indicator-project.js appear in your dist folder. That’s your ready-to-use indicator, hot and shiny.

Curious about the next step? Head over to the to learn how to bring your indicator into FTO and watch it in action on a chart.

This is a separate guide on how to set up the environment to write your custom indicator for FTO.

To to use our custom indicator API, you need to first download indicator example. You can find some of the examples here or download the suggested example file below.

Open it with Cursor or any IDE of your choice — we suggest Cursor. Then, by clicking the icon shown in Picture #1, open the terminal and install the dependencies using the command npm install.

After installing the dependencies, build the project using the command npm run build.

After building the project, a file my-indicator-project.js (Indicator file name) will appear in the dist folder.

If you want to know how to upload your indicator to FTO, you can go to .

1. Download and Install Cursor

First, grab the Cursor editor from cursor.com/downloads.

Run the installer and, when it asks about options, tick all the checkboxes — trust us, you’ll want those extras (see Picture #1).

Think of it like ordering pizza with all the toppings. The more boxes you check, the more powerful Cursor becomes.

2. Install Node.js and Get the Example Project

Next up, you’ll need Node.js. If you don’t already have it, grab it here: .

Run the installer and follow the steps — nothing fancy.

Once Node.js is ready, download the indicator example archive we’ve provided below and extract it to a convenient spot. Desktop, Downloads — anywhere you’ll remember.

Tip: Keep it somewhere easy to find — we’ll open it in Cursor soon.

3. Open the Project in Cursor

Once you’ve unzipped the archive, open the Moving Average folder.

Inside, you’ll find another folder called custom_indicator — that’s where the action is.

Open it with Cursor (see Picture #2 and #3).

Tip: If you see those folders exactly as described, you’re in the right place. Cursor is now ready to load your project.

4. Trust the Authors

If a pop-up appears saying something like “Do you trust the authors?”, don’t panic. It’s just Cursor being cautious.

Click “Yes, I trust the authors” — this simply lets the IDE know it’s safe to open the files.

Tip: This is a normal step whenever you open a project for the first time. Cursor just wants to make sure you’re cool with the code you’re about to run.

5. Open the Terminal and Install Dependencies

Next, click the little terminal icon (see Picture #5) — it’s your gateway to the behind-the-scenes magic. Once it’s open, type this command and hit Enter:

This will download and set up everything your indicator needs to run. Think of it as unpacking your toolbox before you start building.

Tip: If your screen starts showing a bunch of green and white text, you’re doing great — Cursor is fetching all the right pieces.

6. Start Writing and Build Your Indicator

Once the dependencies are installed, it’s showtime — open the index.ts file and start coding your indicator. This is your playground: add logic, tweak parameters, and let your creativity flow. When you’re happy with your code, it’s time to turn it into something FTO can actually use.

Open the terminal again and run:

7. Find Your Finished Indicator

Once the build is complete, you’ll see a shiny new file appear in your dist folder called my-indicator-project.js (or whatever name you gave it). This is your ready-to-use indicator — the one you’ll upload into Forex Tester Online.

Tip: Don’t move or rename it yet; FTO expects it just like this when you upload.

Upload this file to the FTO (Picture #6 and #7).

Once you’ve uploaded the file, your indicator will appear in the “My Indicators” dropdown menu (see Picture #8).

From here, it’s just a click away: pick your indicator, apply it, and watch it show up on your chart.

That’s a wrap!

You’ve gone from setting up Cursor to building, uploading, and running your own custom indicator in Forex Tester Online. Now you know how to prepare your environment, guide the AI, and see your work come to life on a chart. Keep experimenting, keep refining, and if you ever get stuck, teams like are there to help. Build more, debug less, and enjoy the process!

Ready to create your first custom indicator? Let’s start with a classic: the Moving Average.

In this tutorial, we’ll walk step by step through building, coding, and running this popular indicator in FTO.

Don’t worry — even if you’re new to indicators, this one’s a great warm-up. By the end, you’ll have a working Moving Average ready to test and tweak on your charts.

To see how things work in practice, start by downloading the archive with the indicator example.

Once it’s on your computer, open it in any IDE you like — but we highly recommend Cursor IDE for the smoothest experience.

You can download the archive of Moving Average from here

How Custom Indicators Are Built

Every custom indicator in FTO starts with a simple but powerful idea: extend the IndicatorImplementation class from the forex-tester-custom-indicator-api library.

This class gives you all the building blocks you need — methods, structures, and tools — so you can focus on your logic instead of reinventing the wheel.

You can see a working version of this in action in the Moving Average example, which we described earlier in the section. It’s a great place to peek at the code and understand how everything fits together.

Indicator Parameters

Every custom indicator can have its own set of adjustable parameters — things like periods, colors, or calculation methods.

These parameters are defined using the class, which handles different types (numbers, booleans, lists, etc.) and makes them easy to edit.

When you add or edit your indicator in FTO, these parameters will appear in a user-friendly window where you (or your users) can tweak the settings to get just the right behavior.

Think of it as the dashboard for your indicator — all the knobs and switches in one place.

For this, they need to be registered in the function.

Registering Parameters

Defining parameters is only half the story — to actually use them in your indicator, they need to be registered inside the function. This is where you “introduce” your parameters to FTO so they’ll show up in the indicator settings window.

Without registration, your parameters will just sit quietly in the code, never making it to the user interface.

Think of Init as the guest list at a party — if you don’t put your parameter on the list, it won’t get through the door.

You can see the methods for registering parameters in the

Where to Find Registration Methods

All the methods you’ll need to register your parameters live in the section of the API.

That’s the place where FTO tells you: “Here’s how to make your parameters visible in the UI and ready for users to tweak.”

So whenever you’re setting up parameters in the Init function, just look back at those definitions — they’re your cheat sheet for getting everything hooked up the right way.

Tip: Without registration, parameters stay hidden in the code. With registration, they become clickable, adjustable settings in the indicator window.

Buffers setup

are the backstage crew of your indicator.

They’re used to store all those calculated values and then display them as lines, histograms, or other visuals right on your chart.

Think of them as the buckets where your indicator keeps its data before painting it onto the screen.

No buffers = no output. With buffers, your calculations finally become visible magic on the chart.

Buffers need to be both declared as class fields and initialized inside the function.

Connecting Buffers to the Chart

Creating buffers is just the start — now you need to tell FTO how many buffers will actually show up on the chart, and then bind each one by its index (starting from 0).

Each index must be unique, like seat numbers in a cinema.

In this example, we only need one buffer, so the setup looks like this:

• IndicatorBuffers(1) → tells FTO, “I’ve got one buffer to draw.”

• SetIndexBuffer(0, this.SSMA) → assigns our buffer SSMA to slot #0 on the chart.

Tip: If you ever add more buffers later (say, for multiple lines), just increase the number in IndicatorBuffers() and assign each one to its own index.

Configuring Buffers

Each registered buffer isn’t just a data bucket — you can also how it’s displayed on the chart.

For example:

• SetIndexLabel(0, "MA") → gives your buffer a friendly name (“MA”) so it shows up in the legend.

• SetIndexStyle(...) → sets how it looks: here it’s a solid red line with thickness 1.

• SetIndexDrawBegin(...) → defines the point on the chart where drawing should start (usually after enough data has been collected).

Tip: Don’t be afraid to play with colors, line styles, and labels. It’s your indicator — make it not only useful but also easy to read at a glance.

Other settings

Always Recalculate (or Not?)

Inside the function, you can use a handy setting called . By default, FTO calculates each buffer index only once to save resources. That’s efficient, but sometimes it means your indicator won’t be as accurate as you’d like.

If your calculations aren’t too heavy for the processor, we recommend always enabling this option. It ensures your indicator updates on every tick, keeping results fresh and reliable.

Tip: Think of it as “live mode” for your indicator — better accuracy in exchange for a tiny bit more CPU work.

Give Your Indicator a Name

Every indicator deserves an identity. With ., you set the name that will show up in the indicator settings window and the context menu.

Think of it as the little nametag your indicator wears — something short, clear, and easy to recognize when you’re scrolling through the list.

Tip: Keep it simple (like “Moving Average” or “OBV”) so you instantly know what it is at a glance.

Choose Where to Draw

By default, some indicators want to open their own little subwindow under the main chart. But for a Moving Average, it makes much more sense to see it directly on the main chart, hugging the price candles where it belongs.

That’s where comes in — it tells FTO exactly where to draw your indicator. In this case, we point it to the main chart so the Moving Average is right there in the action.

Tip: If you’re building other indicators (like oscillators), you can send them to their own window instead. For Moving Average, keep it on the main chart for the clearest view.

Skip the Zeroes

Sometimes indicators calculate values that are just 0 — and honestly, those don’t tell us much. With , you can tell FTO not to draw these points at all.

That way, the chart stays clean, without random flat lines cluttering your view.

Tip: Think of it like editing out background noise from a song — you only keep the meaningful parts, so the final output looks and sounds better.

Indicator's main function

At the heart of every custom indicator is the function. This is where the real action happens — all the math, logic, and updates take place here on each tick.

Changing parameters

Sometimes you want your indicator to react when the user changes its settings — that’s where the method comes in.

This method lets you add custom logic that runs right after parameters are updated. For example, in the Moving Average indicator it’s used to handle the horizontal shift, so the line moves correctly on the chart when the shift value changes.

OnParamsChange is especially handy if your indicator uses custom objects or needs to redraw elements whenever a parameter is tweaked.

Tip: Think of it as your indicator’s “refresh button” — it makes sure the chart always reflects the latest settings the user has chosen.

Wrapping Up

And there you have it — you’ve just built and understood your first custom indicator: the Moving Average.

From setting up parameters and buffers to configuring styles and handling recalculations, you now know the essential steps behind making an indicator come alive in FTO.

This is a solid foundation — once you’ve mastered the Moving Average, you’re ready to experiment, tweak, and create even more powerful custom tools for your trading.

Below you’ll find three example files — grab them, test them in FTO, and use them as a base for your custom indicators.

To open the Cursor AI panel, press Ctrl+L or click the icon in the top right corner of the Cursor IDE (see Picture #1).

This will open the chat interface — your command center for talking to the AI (yes, it listens — and it’s surprisingly helpful). In Cursor version 1.3.9, there are three available modes: Agent, Ask, and Background (see Picture #2).

Choosing Your AI Mode

Each one plays a different role in your coding adventure.

Agent Mode

Think of it as your AI pair programmer. It sees your project, suggests edits, and you can thumbs-up or thumbs-down its ideas like a benevolent overlord.

Ask Mode

Your Q&A corner. Need to know how a moving average works? Why your code screams in red? Ask away.

Background Mode

This one works behind the scenes. Cursor quietly watches your code and offers suggestions only when relevant. It won’t interrupt you — unless it has something genuinely useful to say. The real magic? You can feed Cursor extra context from your files or docs — like giving it caffeine for smarter replies.

For now, select Agent Mode.

Choosing the Right Brain for the Job

Next to the mode selector, you’ll also see an AI model dropdown. Just leave it on Auto for now — let Cursor pick the right brain for the job (see Picture #3).

Quick warning:

Skip Gemini. Cursor and Gemini aren’t exactly BFFs — context issues, buggy behavior, you name it. If you do want to pick a model manually, stick to Claude or OpenAI. Cursor was trained to jam with them, and the experience is smooth.

Once you’ve taken this quick tour, you’re all set to dive into building your first custom indicator. Next step — sleeves up (real or metaphorical) and let’s create something awesome for FTO.\

import { IndicatorImplementation } from "forex-tester-custom-indicator-api";

export default class IndicatorName extends IndicatorImplementation {
  // parameters

  public Init(): void {
    // initialization logic
  }

  public Calculate(index: number): void {
    // calculation logic
  }

  public OnParamsChange(): void {
    // logic after parameters change
  }

  public Done(): void {
    // logic after finishing the calculation
  }

  public OnHide(): void {
    // logic after hiding the indicator
  }

  public OnShow(): void {
    // logic after showing the indicator
  }
}

Description of the structure

Main methods of each indicator are Init and Calculate, Init is called once when the indicator is created, and Calculate is called on each tick. Other methods are optional and can be used to add additional logic to the indicator.

To get familiar with other methods, you can read the documentation for each method.

• OnParamsChange

Alright, the warm-up is done — now it’s time to get your hands dirty (figuratively).

This is where we actually start writing code for your custom indicator.

Before we dive into coding, make sure your setup is ready to roll. You’ll need access to the FTO Indicator API to make things work smoothly.

Not there yet? No problem — check out the setup guide first, get your environment prepped, and then come back here. It’s a quick read and will save you a ton of head-scratching later.

For this example, we’ll let Cursor do some of the heavy lifting: we’ll ask it to create the On Balance Volume (OBV) indicator for us. We’ll start simple — with a completely empty file — so you can see the process from scratch. Later, when you’re more comfortable, you can speed things up by using some of our pre-built indicator foundations (you’ll find them in this section).

Think of this as baking your first cake from flour and sugar — once you’ve got the hang of it, you can use ready-made mixes to save time.

When we asked Cursor to create the OBV indicator, we didn’t just say “do it.” We gave it some context — included the FTO Indicator documentation and the Rules we set up earlier. In the screenshot (Picture #1), you can see exactly which parts of the documentation Cursor decided to use. It’s like watching your AI buddy flip through the manual before giving you the best answer.

In the result, we got code below

Time for a Quick Fix

The current logic looks solid so far, but there’s a catch: it’s locked to using the Close price only. That’s a bit limiting, right? What if someone wants to use the High, Low, or Open price instead?

No worries — let’s get Cursor to step up its game. We’ll ask it to tweak the code so users can pick their preferred price type. (See Picture #2 to follow along.)

Cursor’s Updated Code

After we asked Cursor to improve the OBV indicator, here’s what it came up with in its second response.

This version lets users choose the price type instead of being stuck with the Close price — nice upgrade! (See below.)

A Little Upgrade Goes a Long Way

With that new parameter and internal method added, Cursor gives us a neat bonus: a dropdown menu for choosing the price type.

No more hardcoded Close price — now you can pick what you need right from the list. (See Picture #3 — that’s your shiny new option selector!)

Wrapping Up

And that’s it — with just two simple requests, Cursor delivered a fully working OBV indicator.

All it took was a proper setup, some clear , and a bit of documentation magic to give it the right context.

Not bad for a few clicks, right? Less typing, more building.

This is a separate guide on how to upload your indicator to FTO.

If you have created an indicator that you want to upload and have run the npm run build command in the terminal, a file named my-indicator-project.js (indicator's file name) will appear in the dist folder. Upload this file to FTO (see Picture #1 and #2).

From there, your indicator should appear in "My Indicators" dropdown menu (Picture #3).

Download and install the Cursor editor: https://www.cursor.com/downloads, while installing make sure to check all the checkmarks (Picture #1)

Then, you have to install Node.js if you don't already have it. Use the link below. https://nodejs.org/en

After installing node.js, download the archive with the indicator example below and extract it to a convenient location.

Open the extracted folder "Moving Average" and inside of it you should find another folder "custom_indicator", open it with Cursor (Picture #2 and #3).

If you get a pop-up like this, click "Yes, I trust the authors"

Then, by clicking the icon shown on Picture #5 you should open the terminal and install the dependencies using the command npm install.

After installing the dependencies, you can start writing your indicator in the index.ts file.

Once the implementation is complete, you can build the project using the command npm run build.

After building the project, a file my-indicator-project.js (Indicator file name) will appear in the dist folder.

Upload this file to the FTO (Picture #6 and #7).

From there, your indicator should appear in "My Indicators" dropdown menu (Picture #8).

Introduction

Cursor IDE is a fork of VS Code that has powerful AI capabilities, allowing it to access your code directly and have information about your project.

Cursor can also be provided with FTO custom indicator documentation to assist in creating new indicators.

Step 1: Install Cursor and set up the project

How to install Cursor and set up the project is described in guide. If you don’t yet know how to set up your environment to work with the FTO API for indicators, that is also covered in the same guide.

Step 2: Apply Cursor Rules

The feature in Cursor IDE allows users to define custom guidelines or behaviors that the AI should follow when generating code. By setting up rules that describe how indicators work in FTO, you can effectively teach Cursor the context it needs to produce accurate and consistent indicators.

To set up global rules for Cursor, click the setting icon (Picture #1)

From here, click the Rules setting (Picture #2)\

In the User Rules field (Picture #3), download and paste contents of the file below called Rules.txt

Step 3: Upload FTO indicator documentation to Cursor

You can upload the FTO indicator documentation to Cursor, and Cursor will be able to use it to help you create new indicators.

To upload the FTO indicator documentation to Cursor, you need to follow these steps:

1. Click the setting icon in the top right corner of the Cursor IDE. (Picture #4)

2. Select "Features" on the left sidebar (Picture #5).

1. Scroll down until you see Docs (Picture #6)

1. Click on the "Add new doc" button and insert link https://fto-2.gitbook.io/fto-indicators-docs to the FTO indicator documentation (Picture #7).

After some indexing, Cursor will be able to refer to the documentation to help you create new indicators.

To become more familiar with how to use this added documentation in your requests to Cursor, go to the section below.

Step 4: Getting familiar with Cursor

To open Cursors AI window, you can press Ctrl+L or click on the icon in the top right corner of the Cursor IDE (Picture #8)

This panel has a chat interface and in Cursor version 0.47.8 it has 3 modes, Agent, Ask and Edit,

each catering to different needs during development (Picture #9).

• Agent Mode: This mode allows for automated code generation and completion by interacting with the AI. It helps streamline the coding process by providing intelligent suggestions and solutions. I access your project files directly and suggests code which you can accept or reject

• Ask Mode: In this mode, developers can ask questions about their codebase, programming concepts, or any development-related topics. The AI will respond with helpful guidance and explanations.

• Edit Mode: Edit Mode assists in making modifications to the existing code. It aids in refactoring, simplifying, or improving code sections as needed.

What makes these modes powerful is the ability to add context directly from your project or documentation

For now, select the Ask mode

Next to the "select mode menu" there is also an option to select a model of AI that we want to use, for now we should choose Auto-select (Picture#10).

Step 5: Start building

Before we begin writing the indicator, it is expected that you are familiar with how to set up the environment to access the FTO Indicator API. If not, please read guide first before continuing.

For this example, we will ask Cursor to implement the On Balance Volume (OBV) indicator for us. In this guide, we will start with an empty file, but for future indicator implementations, you can use some of our indicator foundations provided in .

In the request to create the OBV indicator for us, I included the FTO documentation for and added the discussed earlier. In the screenshot, you can see the sections of the documentation it decided to use (Picture #11).

In the result, we got code below

The current logic seems correct, but it's using only the Close price, and there is currently no way for the user to specify their own price type. Let's ask it to fix that (Picture #12).

The code that Cursor wrote in his second response is below

And with the addition of this new parameter and internal method, we get a nice dropdown with price types (Picture #13).

So in the end, we got a proper indicator with just two simple requests by setting up Cursor properly and providing it with and documentation for context.

Recommendations

For Cursor to use the documentation that we provided in we need to do the following:

Start by selecting the Ask mode and add context to your query by typing @ and selecting Docs from the drop-down menu (Picture #14).

In the drop-down menu, select FTO Indicator documentation, which we added earlier in (Picture#15)

And provide add a file in which you want to create the indicator, you can do it by drag and dropping it from explorer window on the left onto the chat window or finding it in the @ drop-down menu under Files & folders (Picture #16)

What is it?

The OnHide method is called automatically when the indicator is hidden from the chart — for example, when the user disables its visibility.

This gives you a place to clean up any visual elements or perform other logic when the indicator is no longer visible.

Syntax

When and Why to Use It

Use OnHide when you want to:

• Remove custom chart objects (labels, lines, shapes) added by the indicator

• Free resources or stop background logic tied to visualization

• Prepare for a clean re-render when the indicator is shown again

Example

Important Notes

• OnHide only runs when the indicator becomes hidden — not when it is removed completely.

• It pairs naturally with OnShow, helping you manage custom visual elements.

The Rules feature in Cursor IDE allows users to define custom guidelines or behaviors that the AI should follow when generating code. By setting up rules that describe how indicators work in FTO, you can effectively teach Cursor the context it needs to produce accurate and consistent indicators.

To set up global rules for Cursor, click the setting icon (Picture #1)

From here, click the Rules setting (Picture #2)

In the User Rules field (Picture #3), download and paste contents of the file below called Rules.txt

What is it?

The OnParamsChange method is called automatically when the user changes any parameter of your indicator — for example, the period, color, MA type, etc.

It allows you to respond to these changes and implement custom logic that should happen when parameters are modified.

Important: This method is NOT used for the actual parameter values to change — that happens internally. This method is only for custom logic that needs to be executed when parameters are changed.

Syntax

When and Why to Use It

This method is called after the user updates the settings in the indicator panel, but before the indicator is recalculated.

Use OnParamsChange() When You Need To:

• Recalculate internal values based on new parameter values

• Adjust or re-create custom chart objects (lines, labels, etc.)

• Update dependencies between parameters

• Perform validation or parameter-based setup

Don't Use OnParamsChange() If:

• You only need basic parameter changes (values update automatically)

• You don't have any custom logic dependent on parameter changes

• Your indicator works fine with just and

What CAN Be Done in OnParamsChange

Buffer and Display Updates

• Modify buffer properties (styles, labels, visibility)

• Update buffer configuration based on parameter changes

• Reconfigure drawing styles and colors

• Adjust buffer drawing ranges with

Chart Object Management

• Create, modify, or remove custom chart objects

• Update object positions based on parameter changes

• Reconfigure object properties (colors, styles, positions)

• Manage dynamic visual elements

Internal State Management

• Reset calculation counters or accumulators

• Update lookup tables or cached calculations

• Reconfigure internal algorithms based on parameters

• Initialize parameter-dependent variables

What CANNOT Be Done in OnParamsChange

❌ Forbidden Operations

• Heavy calculations or complex mathematical operations

• Per-bar data processing (this should be in )

• Modifying the actual parameter values (handled internally)

• Creating new parameters (must be done in )

❌ Wrong Approach

✅ Correct Approach

Practical Examples

Example 1: Dynamic Buffer Styling

Example 2: Parameter Validation and Dependencies

Example 3: Chart Object Management

Best Practices

✅ Do This

• Keep it lightweight - only essential parameter-dependent logic

• Use it for setup/configuration that depends on parameters

• Reset internal state when parameters change

• Update visual properties based on parameter values

❌ Avoid This

• Heavy computational work (belongs in Calculate())

• Complex loops or data processing

• Modifying parameter values

• Creating new parameters or buffers (belongs in Init()

When NOT to Implement OnParamsChange()

You can skip implementing this method if:

• Your indicator only uses basic parameters for calculations

• No custom logic is needed when parameters change

• All parameter-dependent behavior happens in Calculate()

• You don't have dynamic visual elements or chart objects

Key Rules Summary

1. OnParamsChange() is optional - only implement if you need custom logic

2. Keep it lightweight - no heavy calculations or data processing

3. Parameter values update automatically - this method is for additional logic only

4. Use it for configuration and setup that depends on parameter values

Pro Tip

Think of OnParamsChange() as your "parameter change reaction" method. It's the perfect place to update anything that depends on parameter values but doesn't belong in the per-bar Calculate() method. Keep it fast and focused on configuration rather than calculation.

What is it?

The OnShow method is called when the indicator is made visible on the chart. This includes the moment it’s re-enabled after being hidden.

Syntax

When and Why to Use It

Use OnShow when you need to:

• Re-create or re-draw custom chart objects

• Restore visual elements that were removed or hidden earlier

• Trigger any logic that should happen only when the indicator is visible

This method is helpful when your indicator includes dynamic elements (like shapes, labels, or highlights) that should appear only when the indicator is active.

Example

Important Notes

• This method is not called during every tick or calculation — only when visibility changes.

• If your indicator does not rely on custom objects or UI elements, you may not need to implement OnShow.

What is it?

The Calculate method is one of the core functions used in a custom indicator. It’s responsible for calculating the logic of your indicator for each bar (candle) on the chart.

This function runs automatically on each price update (tick) and recalculates values for the given bar.

How It Works

• index — This parameter tells you which bar you’re working with.

  • index = 0 → the latest bar (rightmost on the chart).

  • index = 1 → the previous bar, and so on.

Example Explained

What This Code Does

1. Checks if there are enough bars to calculate the moving average. (We need Period number of candles; otherwise, we skip.)

2. Calculates a Moving Average value using GetMA().

3. Stores the result in the SMA buffer, which is used for drawing on the chart.

In Short

• This method is where you put your main logic.

• It runs automatically for each bar.

• You should use it to calculate and store indicator values.

• Buffers like SMA and SSMA are how your indicator shows up visually on the chart.

What is it?

The Init method is called once, right when your custom indicator is created or loaded onto the chart. This is where you set everything up — like naming your indicator, creating buffers, creating parameters and registering them, and more.

Syntax

What MUST Be Done in Init

This method is like a constructor for your indicator. Here's what must happen inside:

1. Create and Register Parameters

All user-configurable parameters must be:

• Declared as class-level fields using the ! syntax

• Created in Init() using appropriate factory methods

• Registered using to appear in the UI

2. Create and Configure Buffers

Buffers determine visualization and must be properly set up:

3. Set Indicator Properties

• Name: this.api.IndicatorShortName("Your Indicator Name")

• Output Window: this.api.SetOutputWindow(TOutputWindow.CHART_WINDOW) or TOutputWindow.SEPARATE_WINDOW

What CAN Be Done in Init

Core Setup Methods

• this.api.IndicatorShortName(name) - Set indicator display name

• this.api.IndicatorBuffers(count) - Register number of buffers

• this.api.CreateIndexBuffer() - Create buffer instances

Buffer Configuration Methods

• this.api.SetIndexLabel(index, label) - Set buffer legend label

• this.api.SetIndexStyle(index, drawStyle, penStyle, width, color) - Set visual style

• this.api.SetIndexDrawBegin(index, startBar) - Set drawing start point

Parameter Configuration Methods

• this.api.SetOptionRange(name, min, max) - Set parameter limits

• this.api.SetOptionDigits(name, digits) - Set decimal places

• this.api.AddOptionValue(name, value) - Add dropdown options

Recommended Methods

• this.api.RecalculateMeAlways() - Improves calculation accuracy but could slow down the performance of the indicator

• this.api.SetOutputWindow(window) - Configure chart vs oscillator window

Advanced Configuration Methods

• this.api.AddLevel(value) - Add horizontal reference lines

• this.api.SetLevelValue(index, value) - Set level values

• this.api.SetFixedMinMaxValues(min, max) - Set fixed scale range

What CANNOT Be Done in Init

❌ Forbidden Operations

• Heavy calculations or complex mathematical operations

• Per-bar data processing (use Calculate() instead)

• Accessing bar data like this.api.Close(index), this.api.High(index), etc.

❌ Wrong Approach

✅ Correct Approach

Complete Example

Key Rules Summary

1. Init() is for setup only - no calculations or data processing

2. All parameters must be created AND registered in Init()

3. All buffers must be declared, created, and configured in Init()

4. Use factory methods for parameter creation (, etc.)

Pro Tip

Remember: Init() runs once when the indicator loads. It defines the structure, settings, and appearance. All dynamic calculations and data processing must happen in which runs once per bar.

What Is It?

TOptValue_str is a class used to define string parameters in custom indicators. It allows users to enter or modify text values in the indicator settings panel.

Use the createTOptValue_str() method from the api object inside Init() method to create an instance.

When to Use

Use TOptValue_str when you want to let the user:

• Input custom labels or names

• Define identifiers or tags

• Set any free-form text value

Syntax

Example

In this example:

• Name is a string parameter that can be changed by the user.

• The value can be accessed via this.Name.value.

Notes

• Don't forget to register string parameters using inside the method.

• You can use the value directly in Calculate, OnShow, or other methods as needed.

This is documentation for different types of TOptValue classes which are used to create parameters for indicators.

• TOptValue_str

• TOptValue_number

• TOptValue_bool

What Is It?

TOptValue_bool is a class used to define boolean (true/false) parameters in custom indicators. It allows users to enable or disable certain features through the indicator settings panel.

Use the createTOptValue_bool() method from the api object inside Init() method to create an instance.

When to Use

Use TOptValue_bool when you want to let the user:

• Toggle a feature on or off

• Show or hide additional elements

• Enable conditional behavior in your indicator

Syntax

Example

In this example:

• IsEnabled allows the user to toggle indicator logic on or off.

• Inside Calculate(), the logic runs only if the toggle is true.

Notes

• Don't forget to register string parameters using inside the method.

• You can use the value directly in , , or other methods as needed.

• Access the value with this.MyFlag.value.

What is it?

The Done method is called once, after the indicator has finished calculating all bars. It marks the end of the calculation cycle and is typically used for final steps or cleanup.

Syntax

When and Why to Use It

Use Done when you need to:

• Perform post-processing after all Calculate() calls are complete

• Draw or update custom chart objects that rely on full data

• Clean up temporary data or buffers

• Log or store final values

This method is especially useful if your indicator logic depends on seeing the entire dataset.

Example

Important Notes

• Done is called after all bars have been processed in Calculate().

• It runs once per full calculation cycle — not on every tick.

• It’s safe to use this method to add chart decorations, logs, or summary calculations.

What Is It?

TOptValue_LineStyle is a class used to define line style parameters for custom indicators. It allows users to configure line appearance (visibility, color, style, width) through the indicator settings panel.

Use the createTOptValue_LineStyle() method from the api object inside Init() method to create an instance.

When to Use

Use TOptValue_LineStyle when you want to let the user configure line appearance for:

• Support/resistance levels

• Trend lines

• Other visual elements on charts

Syntax

Example

In this example:

• LineStyle allows the user to configure line appearance

• Inside Calculate(), a horizontal line is created with the configured style

• The line is positioned at the current bar's close price

Notes

• Don't forget to register line style parameters using inside the method.

• Use TOptionType.LINE when registering TOptValue_LineStyle parameters.

• Access properties with this.MyLineStyle.isVisible, this.MyLineStyle.color, this.MyLineStyle.style

What Are Parameters?

Indicator parameters are configurable settings that allow users to customize how an indicator behaves and looks. They appear in the indicator’s settings panel and can be modified without changing the code.

How It Works

To make a parameter configurable, it must be created using one of the TOptValue types , created and registered inside the Init() method.

Any variable that does not extend TOptValue is considered internal and will not be visible or editable in the user interface.

Common Parameter Types

Here are some of the commonly used TOptValue types:

• TOptValue_number — numeric values (e.g., period, shift)

• TOptValue_bool — true/false switches

• TOptValue_string — string input

Example

Key Rules

• Only -based parameters are configurable

• You must register each parameter inside the method using

• Parameters control how the indicator works and looks — use them for anything the user might want to tweak

What Is It?

TOptValue_number is a class used to define numeric parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust numbers such as periods, shifts, price types, and more.

You must use the createTOptValue_number() method of the api object inside Init() method to create an instance.

When to Use

Use TOptValue_number when you need a configurable parameter of type number, such as:

• Period length for moving averages

• Shift values

• Enum values (e.g., MA type, price type)

• Any numeric input from the user

Syntax

Example

In this example:

• Period controls how many bars are used in the moving average calculation.

• Shift can offset the indicator horizontally.

• MAtype selects the type of moving average (e.g., SMA, EMA).

Notes

• After creating a parameter, don’t forget to register it using in the method.

• You can access the value using this.MyParameter.value.

Returns the open price of a bar in the specified symbol's price history.

Syntax

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

• index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the open price of the specified bar.

Description

The iOpen method retrieves the opening price of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

Returns the tick volume of a bar in the specified symbol's price history.

Syntax

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

• index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the tick volume of the specified bar.

Description

The iVolume method retrieves the tick volume of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar. The volume represents the number of price changes (ticks) that occurred during the bar period.

Example

What Is It?

TOptValue_DateOnly is a class used to define date-only parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust date values without time information, such as specific trading days, start dates, or end dates.

You must use the createTOptValue_DateOnly() method of the api object inside Init() method to create an instance.

When to Use

Use TOptValue_DateOnly when you need a configurable parameter of date only, such as:

• Start date for calculations (without specific time)

• End date for a period (without specific time)

• Specific trading day to highlight or filter

• Date-based filters that don't require time precision

Syntax

Example

In this example:

• StartDate defines the beginning of the analysis period.

• EndDate defines the end of the analysis period.

Notes

• After creating a parameter, don't forget to register it using in the method.

• You can access the value using this.MyDateParameter.value.

• Use TOptionType.DATE_ONLY when registering this parameter type.

Returns the lowest price of a bar in the specified symbol's price history.

Syntax

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

• index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the lowest price of the specified bar.

Description

The iLow method retrieves the lowest price reached during a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

Returns the index of the bar with the highest value over a specified range.

Syntax

Parameters

• symbol: The symbol to get data for

• timeFrame: The timeframe of the data (in minutes)

• type: The price type to compare (0=OPEN, 1=HIGH, 2=LOW, 3=CLOSE, 4=VOLUME)

• count: Number of bars to search through

• index: The starting bar index (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the index of the bar with the highest value. Returns -1 if no valid bar is found.

Description

The iHighest method searches for the bar with the highest value of the specified price type (open, high, low, close, or volume) within a range of bars. The search starts from the specified index and looks back for the specified number of bars. The method is useful for finding local maxima and implementing various technical analysis strategies.

Example

Returns the highest price of a bar in the specified symbol's price history.

Syntax

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

• index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the highest price of the specified bar.

Description

The iHigh method retrieves the highest price reached during a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar.

Example

Returns the index of the bar with the lowest value over a specified range.

Syntax

Parameters

• symbol: The symbol to get data for

• timeFrame: The timeframe of the data (in minutes)

• type: The price type to compare (0=OPEN, 1=HIGH, 2=LOW, 3=CLOSE, 4=VOLUME)

• count: Number of bars to search through

• index: The starting bar index (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns a number representing the index of the bar with the lowest value. Returns -1 if no valid bar is found.

Description

The iLowest method searches for the bar with the lowest value of the specified price type (open, high, low, close, or volume) within a range of bars. The search starts from the specified index and looks back for the specified number of bars. The method is useful for finding local minima and implementing various technical analysis strategies.

Example

This section provides functions to access historical bar data such as open, high, low, close, volume, and time. These functions are essential for building logic in custom indicators.

Available Functions

• Volume : Gets the volume value of the current bar.

• : Retrieves volume value from a specific bar index.

• : Retrieves the timestamp of a specific bar.

• : Retrieves the open price of a specific bar.

• : Finds the lowest value over a range of bars.

• : Gets the low price of a specific bar.

• : Finds the highest value over a range of bars.

• : Gets the high price of a specific bar.

• : Retrieves the close price of a specific bar.

• : Finds the index of a bar by time.

• : Returns the number of bars between two dates.

• : Gets the close price of the current bar.

• : Gets the high price of the current bar.

• : Gets the low price of the current bar.

• : Gets the open price of the current bar.

• : Returns the total number of bars.

• : Gets the time of the current bar.

Click on any function name to view its detailed documentation.

Returns the opening time of a bar in the specified symbol's price history.

Syntax

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

• index: The index of the bar (0 is current/last bar, 1 is previous bar, etc.)

Return Value

Returns an object representing the opening time of the specified bar.

Description

The iTime method retrieves the opening time of a bar at the specified index from the price history of a given symbol and timeframe. The index parameter uses zero-based indexing where 0 represents the current (most recent) bar. The returned time is in UTC timezone.

Example

What Is It?

TOptValue_DateTime is a class used to define date and time parameters for custom indicators. These parameters appear in the indicator settings panel and allow the user to input or adjust date and time values such as start times, end times, or specific moments in trading history.

You must use the createTOptValue_DateTime() method of the api object inside Init() method to create an instance.

When to Use

Use TOptValue_DateTime when you need a configurable parameter of date and time, such as:

• Start date and time for calculations

• End date and time for a period

• Specific moment to trigger indicator behavior

• Time-based filters for trading sessions

Syntax

Notes

• After creating a parameter, don't forget to register it using in the method.

• You can access the value using this.MyDateTimeParameter.value.

• Use TOptionType.DATE_TIME when registering this parameter type.

Overview

To display indicator values on the chart in Forex Tester Online, you need to use buffers. Buffers store the calculated values and define how they should be visualized (e.g., lines, histograms, dots).

Each buffer is created as a TIndexBuffer and configured through API calls.

Step-by-Step Guide

1. Declare the Buffer

All buffers must be declared as class fields using the TIndexBuffer type.

2. Create the Buffer in Init()

Create the buffer instance using the CreateIndexBuffer() method.

3. Register the Number of Buffers

Tell the API how many buffers you plan to use. In this case — one:

This must be called before setting buffer styles or assignments.

4. Bind the Buffer to an Index

Each buffer must be assigned a unique index:

5. Configure the Buffer

You can now customize how the buffer will appear on the chart:

Full Example

Notes

• Each buffer must be declared, created, and registered properly to be visible on the chart.

• Indices must be unique and zero-based (0, 1, 2, etc.).

• You can use multiple buffers to display several lines or visual elements.

Returns the total number of bars available in the specified symbol's price history.

Syntax

iBars(Symbol: string, TimeFrame: number): number

Parameters

• Symbol: The symbol to get data for

• TimeFrame: The timeframe of the data (in minutes)

Return Value

Returns a number representing the total count of available bars.

Description

The iBars method returns the total number of bars available in the price history for a given symbol and timeframe. This count includes all bars from the oldest available bar up to the current (most recent) bar. The method is useful for determining the size of the historical data and for implementing lookback periods in technical analysis.

Example

Returns the time for a specific bar.

Syntax

Parameters

• shift: A number representing the shift from the current bar

• timeZoneMode: Optional. Default value is project timezone. A TimeZoneMode enum value representing the timezone mode to use for the returned date

Return Value

Returns an object representing the bar's opening time.

Description

The Time method returns the opening time of a bar at the specified shift from the current bar. The time is returned as an FTODate object, which provides various date/time manipulation capabilities. The shift parameter determines which bar's time to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

The timeZoneMode parameter allows you to specify how the time should be interpreted:

• TimeZoneMode.PROJECT: Returns time in the project's timezone (default)

• TimeZoneMode.UTC: Returns time in UTC

Example

Returns the total number of chart objects.

Syntax

GetObjectCount(isStatic: boolean = false): number

Parameters

Return Value

Returns a number representing the total count of chart objects.

Description

The GetObjectCount method returns the total number of objects in the chart. It can count either regular objects or static objects, depending on the isStatic parameter.

Example

Returns the bar index for a specified time in the symbol's price history.

Syntax

Parameters

• symbol: The symbol to get data for

• timeframe: The timeframe of the data (in minutes)

• time: The time to search for

• exact: Whether to require an exact match

Return Value

Returns a number representing the index of the bar corresponding to the specified time. Returns -1 if no matching bar is found.

Description

The iBarShift method searches for a bar with a specific opening time and returns its index. If exact is true, only bars with exactly matching times will be considered. If exact is false, the method will return the index of the nearest bar that opened before the specified time.

Example

Returns the highest price for a specific bar.

Syntax

Parameters

• shift: A number representing the shift from the current bar

Return Value

Returns a number representing the highest price reached during the specified bar.

Description

The High method returns the highest price reached during a bar at the specified shift from the current bar. The shift parameter determines which bar's high price to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

Example

Returns the lowest price for a specific bar.

Syntax

Parameters

• shift: A number representing the shift from the current bar

Return Value

Returns a number representing the lowest price reached during the specified bar.

Description

The Low method returns the lowest price reached during a bar at the specified shift from the current bar. The shift parameter determines which bar's low price to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

Example

Returns the opening price for a specific bar.

Syntax

Parameters

• shift: A number representing the shift from the current bar

Return Value

Returns a number representing the opening price of the specified bar.

Description

The Open method returns the opening price of a bar at the specified shift from the current bar. The shift parameter determines which bar's opening price to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

Example

Returns the closing price for a specific bar.

Syntax

Parameters

• shift: A number representing the shift from the current bar

Return Value

Returns a number representing the closing price of the specified bar.

Description

The Close method returns the closing price of a bar at the specified shift from the current bar. The shift parameter determines which bar's closing price to return:

• 0: Current bar

• 1: Previous bar

• 2: Two bars ago

• And so on

Example

Removes all chart objects of a specified type.

Syntax

RemoveAllObjects(objType: TObjectType, isStatic: boolean = false): void

Parameters

Description

The RemoveAllObjects method removes all chart objects of a specified type from the chart. This is useful for cleaning up multiple objects at once. The method can remove either regular objects or static objects, depending on the isStatic parameter.

Example

Returns the type of a chart object.

Syntax

GetObjectType(name: string, isStatic: boolean = false): TObjectType

Parameters

Return Value

Returns a enum value representing the object's type.

Description

The GetObjectType method retrieves the type of a specified chart object. The type is returned as a TObjectType enumeration value.

Example

This section provides functions to manage and interact with chart objects. These functions allow you to create, remove, and modify objects on a chart.

Available Functions

• CreateChartObject: Creates a new chart object.

• : Removes all objects from a chart.

• : Checks if a chart object exists.

• : Retrieves the text of a chart object.

• : Retrieves the type of a chart object.

• : Retrieves the name of a chart object.

• : Retrieves the count of objects on a chart.

• : Removes a specific chart object.

• : Sets the text of a chart object.

• : Retrieves a property of a chart object.

• : Sets a property of a chart object.

Click on any function name to view its detailed documentation.

Returns the total number of bars.

Syntax

Bars(): number

Return Value

Returns a number representing the total count of available bars.

Description

The Bars method returns the total number of price bars available in the current symbol's history. This count includes all bars from the earliest available data point up to and including the current bar.

Example