Integromat Advanced Scenarios for ChatGPT Apps: Production-Grade Automation Patterns
Building ChatGPT applications requires sophisticated automation that goes far beyond simple API calls. Integromat (now Make.com) provides a visual scenario designer that transforms complex multi-step workflows into production-ready automation pipelines. However, basic drag-and-drop configurations quickly hit limitations when handling real-world edge cases, error recovery, and data transformation at scale.
Advanced Integromat scenarios leverage routing patterns, aggregators, iterators, and custom error handlers to create resilient automation systems. These patterns enable ChatGPT applications to process thousands of concurrent conversations, gracefully handle API failures, transform data between incompatible formats, and recover from unexpected errors without human intervention. The difference between a prototype and a production system lies in how effectively scenarios handle the 1% edge cases that occur millions of times at scale.
This guide explores seven production-ready Integromat scenario patterns specifically designed for ChatGPT application workflows. Each pattern includes complete IML (Integromat Markup Language) implementations, performance considerations, and integration strategies with ChatGPT Applications Guide architectures. Whether you're building conversational AI for customer service, lead qualification, or complex decision trees, these advanced scenarios provide the automation foundation your ChatGPT app needs to scale reliably.
Scenario Architecture Fundamentals
Integromat's visual flow designer organizes automation logic into scenarios—directed graphs where nodes (modules) execute sequentially or in parallel. Each scenario begins with a trigger module (webhook, scheduled timer, or watch event) and flows through transformation modules, routers, and action modules before terminating or looping back.
Core Scenario Components:
- Modules: Individual action blocks (HTTP requests, database queries, data transformations)
- Routers: Conditional branching based on filters or expressions
- Aggregators: Combine multiple bundles into arrays or structured objects
- Iterators: Split arrays into individual bundles for parallel processing
- Data Stores: Persistent key-value storage for state management
- Variables: Scenario-level constants and runtime values
Data Flow Model:
Integromat processes data in bundles—immutable objects passed between modules. Each module receives input bundles, executes transformations, and emits output bundles. Routers duplicate bundles across multiple paths, while aggregators collect bundles from parallel branches. Understanding bundle lifecycle is critical for optimizing scenario performance and avoiding unintended side effects.
Variable Mapping:
Modules communicate through variable mapping using dot notation (1.id, 2.response.data). The numeric prefix references module execution order, enabling downstream modules to access upstream outputs. Advanced scenarios use Make.com Custom Modules for reusable logic blocks and complex IML expressions for dynamic variable construction.
Visual vs. IML Design:
While Integromat's drag-and-drop interface suffices for simple workflows, production scenarios require IML (Integromat Markup Language) for conditional logic, error handling, and advanced data transformations. IML provides programmatic control over routing decisions, retry logic, and dynamic module configuration—essential for Complex Workflow Automation in ChatGPT applications.
Complex Routing Patterns
Routing determines how data flows through scenario branches based on runtime conditions. Basic routers evaluate simple filters, but production ChatGPT workflows require sophisticated routing strategies to handle conversation contexts, user permissions, and API rate limits.
Conditional Router with Fallback
This pattern evaluates multiple conditions sequentially, executing the first matching route and falling back to a default handler if no conditions match. Critical for ChatGPT apps that route conversations to different processing pipelines based on user intent, subscription tier, or conversation history.
// Conditional Router: Intent-Based Conversation Routing
// Module: Router (ID: 3)
{
"routes": [
{
"label": "Premium User - Advanced AI",
"filter": {
"name": "Premium Subscription + Complex Query",
"conditions": [
[
{
"a": "{{2.user.subscription_tier}}",
"b": "premium",
"o": "text:equal"
},
{
"a": "{{2.message.intent}}",
"b": "complex_analysis",
"o": "text:equal"
}
]
]
},
"modules": [
{
"id": 4,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-4-turbo-preview",
"messages": [
{
"role": "system",
"content": "You are an advanced AI assistant with deep analytical capabilities."
},
{
"role": "user",
"content": "{{2.message.text}}"
}
],
"temperature": 0.7,
"max_tokens": 2000
}
}
]
},
{
"label": "Standard User - Contextual Response",
"filter": {
"name": "Standard Subscription",
"conditions": [
[
{
"a": "{{2.user.subscription_tier}}",
"b": "standard",
"o": "text:equal"
}
]
]
},
"modules": [
{
"id": 5,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-3.5-turbo",
"messages": "{{2.conversation_history}}",
"temperature": 0.5,
"max_tokens": 500
}
}
]
},
{
"label": "Free User - Rate Limited",
"filter": {
"name": "Free Tier with Rate Check",
"conditions": [
[
{
"a": "{{2.user.subscription_tier}}",
"b": "free",
"o": "text:equal"
},
{
"a": "{{2.user.daily_query_count}}",
"b": 10,
"o": "number:lessequal"
}
]
]
},
"modules": [
{
"id": 6,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "{{2.message.text}}"
}
],
"temperature": 0.3,
"max_tokens": 200
}
}
]
}
],
"fallback": {
"label": "Rate Limit Exceeded / Unknown Tier",
"modules": [
{
"id": 7,
"module": "http:ActionSendData",
"version": 3,
"parameters": {
"url": "{{2.webhook_url}}",
"method": "POST",
"headers": [
{
"name": "Content-Type",
"value": "application/json"
}
],
"body": {
"error": "rate_limit_exceeded",
"message": "Daily query limit reached. Upgrade to continue.",
"user_id": "{{2.user.id}}",
"current_count": "{{2.user.daily_query_count}}",
"upgrade_url": "https://makeaihq.com/pricing"
}
}
}
]
}
}
This router evaluates subscription tiers and query complexity to route ChatGPT requests to appropriate models. Premium users access GPT-4 for complex analysis, standard users receive GPT-3.5 with conversation history, and free users get rate-limited responses. The fallback route handles quota violations and unknown subscription states, ensuring graceful degradation without scenario failures.
Multi-Path Router for Parallel Processing
Parallel routing enables simultaneous execution of independent workflow branches, critical for ChatGPT applications that must update multiple systems (CRM, analytics, knowledge base) after each conversation.
// Multi-Path Router: Parallel Post-Conversation Updates
// Module: Router (ID: 8)
{
"routes": [
{
"label": "Update CRM Contact Record",
"filter": {
"name": "Always Execute",
"conditions": []
},
"modules": [
{
"id": 9,
"module": "salesforce:updateRecord",
"version": 2,
"parameters": {
"record_type": "Contact",
"record_id": "{{2.user.crm_id}}",
"fields": {
"Last_Conversation_Date__c": "{{formatDate(now, 'YYYY-MM-DD')}}",
"Total_Conversations__c": "{{2.user.conversation_count + 1}}",
"Last_Intent__c": "{{2.message.intent}}",
"AI_Engagement_Score__c": "{{2.engagement_score}}"
}
}
}
]
},
{
"label": "Log Analytics Event",
"filter": {
"name": "Always Execute",
"conditions": []
},
"modules": [
{
"id": 10,
"module": "googleanalytics:createEvent",
"version": 1,
"parameters": {
"tracking_id": "{{env.GA_TRACKING_ID}}",
"client_id": "{{2.user.id}}",
"event_category": "ChatGPT Conversation",
"event_action": "{{2.message.intent}}",
"event_label": "{{2.user.subscription_tier}}",
"event_value": "{{2.response.token_count}}"
}
}
]
},
{
"label": "Update Knowledge Base",
"filter": {
"name": "High Quality Response",
"conditions": [
[
{
"a": "{{2.response.quality_score}}",
"b": 0.8,
"o": "number:greaterequal"
}
]
]
},
"modules": [
{
"id": 11,
"module": "airtable:createRecord",
"version": 1,
"parameters": {
"base_id": "{{env.AIRTABLE_BASE_ID}}",
"table_name": "Knowledge Base",
"fields": {
"Question": "{{2.message.text}}",
"Answer": "{{2.response.text}}",
"Intent": "{{2.message.intent}}",
"Quality Score": "{{2.response.quality_score}}",
"Created": "{{now}}"
}
}
}
]
}
]
}
This multi-path router executes three parallel branches after each ChatGPT conversation: CRM updates, analytics logging, and knowledge base curation. All three routes execute simultaneously (unless filtered), reducing total scenario execution time from 3-5 seconds to under 2 seconds compared to sequential processing.
Fallback Router for Resilient API Calls
Production ChatGPT scenarios must handle API failures gracefully. This pattern attempts primary API endpoint, falls back to secondary endpoint on timeout, and queues requests for manual processing if both fail.
// Fallback Router: Resilient OpenAI API with Retry Logic
// Module: Router (ID: 12)
{
"routes": [
{
"label": "Primary OpenAI Endpoint",
"filter": {
"name": "First Attempt",
"conditions": [
[
{
"a": "{{13.retry_count}}",
"b": null,
"o": "exist:false"
}
]
]
},
"modules": [
{
"id": 14,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-4-turbo-preview",
"messages": "{{2.messages}}",
"timeout": 30
},
"error_handlers": [
{
"type": "break",
"resume": false
}
]
}
]
},
{
"label": "Fallback to GPT-3.5 Turbo",
"filter": {
"name": "Primary Failed Once",
"conditions": [
[
{
"a": "{{13.retry_count}}",
"b": 1,
"o": "number:equal"
}
]
]
},
"modules": [
{
"id": 15,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-3.5-turbo",
"messages": "{{2.messages}}",
"max_tokens": 1000,
"timeout": 20
},
"error_handlers": [
{
"type": "break",
"resume": false
}
]
}
]
}
],
"fallback": {
"label": "Queue for Manual Processing",
"modules": [
{
"id": 16,
"module": "datastore:set",
"version": 1,
"parameters": {
"datastore": "failed_requests",
"key": "{{2.request_id}}",
"value": {
"timestamp": "{{now}}",
"user_id": "{{2.user.id}}",
"messages": "{{2.messages}}",
"retry_count": "{{13.retry_count}}",
"error": "{{14.error.message}}"
}
}
},
{
"id": 17,
"module": "slack:sendMessage",
"version": 1,
"parameters": {
"channel": "#ai-errors",
"text": "OpenAI API failed after retries. Request queued: {{2.request_id}}"
}
}
]
}
}
This fallback router attempts GPT-4 first, downgrades to GPT-3.5 on failure, and queues unrecoverable requests to a data store while notifying the ops team via Slack. The retry_count variable tracks attempts across router cycles, preventing infinite loops.
Data Transformation Strategies
ChatGPT API responses rarely match the exact format downstream systems expect. Advanced scenarios transform JSON structures, aggregate arrays, and paginate large datasets using iterators and custom IML functions.
JSON Transformer for API Response Normalization
// JSON Transformer: Normalize OpenAI Response to CRM Format
// Module: Tools -> Set Multiple Variables (ID: 18)
{
"variables": [
{
"name": "normalized_response",
"value": {
"contact_id": "{{2.user.crm_id}}",
"conversation_summary": "{{substring(14.choices[1].message.content, 0, 500)}}",
"full_transcript": "{{map(2.messages, 'role', 'content')}}",
"ai_sentiment": "{{if(contains(14.choices[1].message.content, 'positive'), 'Positive', if(contains(14.choices[1].message.content, 'negative'), 'Negative', 'Neutral'))}}",
"token_usage": {
"prompt_tokens": "{{14.usage.prompt_tokens}}",
"completion_tokens": "{{14.usage.completion_tokens}}",
"total_cost": "{{round((14.usage.prompt_tokens * 0.00001) + (14.usage.completion_tokens * 0.00003), 4)}}"
},
"tags": "{{if(contains(toLower(2.messages[].content), 'pricing'), 'Pricing Inquiry', '')}}{{if(contains(toLower(2.messages[].content), 'demo'), ',Demo Request', '')}}",
"follow_up_required": "{{if(contains(14.choices[1].message.content, 'contact sales'), true, false)}}",
"metadata": {
"model": "{{14.model}}",
"created_at": "{{formatDate(fromTimestamp(14.created), 'YYYY-MM-DD HH:mm:ss')}}",
"scenario_id": "{{scenario.id}}",
"execution_id": "{{execution.id}}"
}
}
},
{
"name": "crm_payload",
"value": {
"Contact_ID": "{{18.normalized_response.contact_id}}",
"Last_AI_Conversation": "{{18.normalized_response.conversation_summary}}",
"AI_Sentiment_Score": "{{18.normalized_response.ai_sentiment}}",
"Total_AI_Cost": "{{18.normalized_response.token_usage.total_cost}}",
"Tags": "{{trim(18.normalized_response.tags, ',')}}",
"Follow_Up_Flag": "{{18.normalized_response.follow_up_required}}",
"Updated_Date": "{{now}}"
}
}
]
}
This transformer converts OpenAI's nested JSON response into a flat CRM-compatible structure. The normalized_response variable extracts relevant data, calculates costs, infers sentiment, and generates tags. The crm_payload variable then maps normalized fields to CRM column names, ready for direct API submission.
Array Aggregator for Batch Processing
When ChatGPT generates multiple recommendations, aggregators collect parallel processing results into a single array for bulk database insertion.
// Array Aggregator: Collect ChatGPT Recommendations
// Module: Array Aggregator (ID: 19)
{
"source_module": 20,
"aggregator_type": "array",
"group_by": "{{2.user.id}}",
"aggregated_fields": [
{
"name": "recommendations",
"type": "array",
"value": {
"recommendation_id": "{{uuid()}}",
"product_name": "{{20.recommendation.product}}",
"confidence_score": "{{20.recommendation.confidence}}",
"reasoning": "{{20.recommendation.reasoning}}",
"price": "{{20.recommendation.price}}",
"url": "{{20.recommendation.url}}"
}
},
{
"name": "total_confidence",
"type": "numeric:sum",
"value": "{{20.recommendation.confidence}}"
},
{
"name": "average_price",
"type": "numeric:avg",
"value": "{{20.recommendation.price}}"
}
],
"target_structure": {
"user_id": "{{2.user.id}}",
"recommendations": "{{19.recommendations}}",
"summary": {
"total_recommendations": "{{length(19.recommendations)}}",
"average_confidence": "{{round(19.total_confidence / length(19.recommendations), 2)}}",
"average_price": "{{round(19.average_price, 2)}}",
"generated_at": "{{now}}"
}
}
}
This aggregator collects product recommendations generated by parallel ChatGPT calls (module 20 iterates over potential products), groups by user ID, and computes aggregate statistics. The output structure combines individual recommendations with summary metrics for dashboard display.
Iterator with Pagination for Large Datasets
// Iterator with Pagination: Process Large Conversation Histories
// Module: Iterator (ID: 21)
{
"array": "{{2.conversation_history}}",
"batch_size": 10,
"process_mode": "sequential",
"modules": [
{
"id": 22,
"module": "openai:CreateChatCompletion",
"version": 1,
"parameters": {
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "system",
"content": "Summarize this conversation exchange in 2-3 sentences."
},
{
"role": "user",
"content": "User: {{21.bundle.user_message}}\nAI: {{21.bundle.ai_response}}"
}
],
"max_tokens": 150
}
},
{
"id": 23,
"module": "datastore:add",
"version": 1,
"parameters": {
"datastore": "conversation_summaries",
"record": {
"conversation_id": "{{21.bundle.id}}",
"summary": "{{22.choices[1].message.content}}",
"original_length": "{{length(21.bundle.user_message) + length(21.bundle.ai_response)}}",
"compression_ratio": "{{round(150 / (length(21.bundle.user_message) + length(21.bundle.ai_response)), 2)}}",
"processed_at": "{{now}}"
}
}
}
],
"pagination": {
"enabled": true,
"delay_seconds": 1,
"max_iterations": 100
}
}
This iterator processes conversation histories in batches of 10, summarizing each exchange with ChatGPT and storing results in a data store. Pagination prevents timeout errors on large datasets, while the 1-second delay respects OpenAI rate limits. For advanced error recovery patterns, see Error Handling Advanced.
Error Handling Advanced Patterns
Production scenarios require sophisticated error handlers that distinguish transient failures (retry) from permanent errors (alert ops team). These patterns implement try-catch logic, rollback mechanisms, and dead letter queues.
Try-Catch Handler with Exponential Backoff
// Try-Catch Handler: Resilient HTTP Request with Backoff
// Module: HTTP Request (ID: 24)
{
"url": "{{2.webhook_url}}",
"method": "POST",
"headers": [
{
"name": "Authorization",
"value": "Bearer {{env.API_TOKEN}}"
}
],
"body": "{{2.payload}}",
"timeout": 30,
"error_handlers": [
{
"type": "retry",
"interval": "{{pow(2, 24.attempt_number) * 1000}}",
"max_attempts": 5,
"break_on_error_codes": [400, 401, 403, 404]
},
{
"type": "ignore",
"resume": true,
"ignore_on_error_codes": [429]
},
{
"type": "commit",
"resume": false,
"commit_on_error_codes": [500, 502, 503]
}
]
}
This error handler implements exponential backoff (2^attempt seconds), retries transient errors (5xx), ignores rate limits (429 - handled upstream), and breaks on permanent errors (4xx). The break_on_error_codes prevents wasted retries on authentication or validation failures.
Rollback Mechanism for Multi-Step Transactions
When ChatGPT-driven workflows update multiple systems, failures midway require rollback to maintain data consistency.
// Rollback Mechanism: Atomic Multi-System Update
// Module: Router (ID: 25)
{
"routes": [
{
"label": "Success Path",
"filter": {
"name": "All Updates Succeeded",
"conditions": [
[
{
"a": "{{26.success}}",
"b": true,
"o": "boolean:equal"
},
{
"a": "{{27.success}}",
"b": true,
"o": "boolean:equal"
},
{
"a": "{{28.success}}",
"b": true,
"o": "boolean:equal"
}
]
]
},
"modules": [
{
"id": 29,
"module": "http:ActionSendData",
"version": 3,
"parameters": {
"url": "{{2.success_webhook}}",
"method": "POST",
"body": {
"status": "committed",
"transaction_id": "{{2.transaction_id}}"
}
}
}
]
}
],
"fallback": {
"label": "Rollback All Changes",
"modules": [
{
"id": 30,
"module": "http:ActionSendData",
"version": 3,
"parameters": {
"url": "{{env.CRM_ROLLBACK_ENDPOINT}}",
"method": "DELETE",
"body": {
"record_id": "{{26.created_id}}"
}
}
},
{
"id": 31,
"module": "datastore:delete",
"version": 1,
"parameters": {
"datastore": "conversation_cache",
"key": "{{27.cache_key}}"
}
},
{
"id": 32,
"module": "slack:sendMessage",
"version": 1,
"parameters": {
"channel": "#ai-errors",
"text": "Transaction {{2.transaction_id}} rolled back due to failure at step {{if(not(26.success), 'CRM', if(not(27.success), 'Cache', 'Analytics'))}}"
}
}
]
}
}
This router validates success flags from three parallel update operations (CRM, cache, analytics). If all succeed, it commits the transaction. If any fail, the fallback route deletes created CRM records, purges cache entries, and alerts the team—ensuring atomic behavior across distributed systems.
Dead Letter Queue for Unrecoverable Errors
// Dead Letter Queue: Store Failed ChatGPT Requests
// Module: Data Store -> Add (ID: 33)
{
"datastore": "dlq_chatgpt_requests",
"record": {
"request_id": "{{uuid()}}",
"original_payload": "{{2.payload}}",
"error_details": {
"module_id": "{{error.module_id}}",
"error_code": "{{error.code}}",
"error_message": "{{error.message}}",
"stack_trace": "{{error.stack}}"
},
"retry_count": "{{2.retry_count}}",
"first_attempt": "{{2.first_attempt_timestamp}}",
"last_attempt": "{{now}}",
"user_context": {
"user_id": "{{2.user.id}}",
"subscription_tier": "{{2.user.subscription_tier}}",
"session_id": "{{2.session_id}}"
},
"status": "pending_manual_review"
}
}
Failed requests after all retry attempts land in this dead letter queue for manual investigation. The stored payload includes full context (user session, retry history, error stack trace) enabling ops teams to reproduce issues and reprocess requests after fixes.
Performance Optimization Strategies
Advanced scenarios balance execution speed, API quota consumption, and error resilience. These optimizations reduce scenario runtime from minutes to seconds while respecting external service rate limits.
Parallel Execution with Controlled Concurrency
// Parallel Execution: Controlled Concurrent API Calls
// Module: Flow Control -> Parallel Processing (ID: 34)
{
"input_array": "{{2.user_ids}}",
"max_concurrent": 5,
"modules": [
{
"id": 35,
"module": "http:ActionSendData",
"version": 3,
"parameters": {
"url": "https://api.openai.com/v1/chat/completions",
"method": "POST",
"headers": [
{
"name": "Authorization",
"value": "Bearer {{env.OPENAI_API_KEY}}"
}
],
"body": {
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Generate personalized email for user {{34.bundle.user_id}}"
}
]
}
}
},
{
"id": 36,
"module": "airtable:updateRecord",
"version": 1,
"parameters": {
"record_id": "{{34.bundle.user_id}}",
"fields": {
"Generated_Email": "{{35.choices[1].message.content}}",
"Generated_At": "{{now}}"
}
}
}
],
"error_handling": {
"on_error": "continue",
"log_errors": true
}
}
This parallel processor generates personalized ChatGPT emails for multiple users simultaneously, limiting concurrency to 5 requests to respect OpenAI rate limits (10,000 RPM / 5 scenarios = 2,000 RPM per scenario). Processing 100 users sequentially takes ~300 seconds; parallel execution completes in ~60 seconds.
Scenario Scheduling & Quota Management:
For production ChatGPT applications processing thousands of daily conversations, configure scenarios with:
- Instant triggers (webhooks) for real-time user interactions
- Scheduled triggers (every 15 minutes) for batch summarization and analytics
- Watch triggers (new database records) for asynchronous post-processing
Monitor Integromat operation quotas (10,000/month on Free, unlimited on Pro) and OpenAI token quotas (rate limits, monthly spend caps) through scenario execution logs. For quota optimization strategies in complex workflows, explore Complex Workflow Automation landing page resources.
Production Deployment Checklist
Before launching advanced Integromat scenarios for ChatGPT applications:
- Error handlers on ALL external API calls (OpenAI, CRM, databases)
- Exponential backoff configured (prevents thundering herd on transient failures)
- Dead letter queue implemented (stores unrecoverable requests for manual review)
- Rollback mechanisms validated (test failure scenarios manually)
- Rate limits respected (max concurrent requests ≤ API quota / scenarios)
- Scenario execution logs monitored (set alerts for error rate > 5%)
- Variable mapping validated (test with null/empty/malformed inputs)
- Data store quotas checked (Integromat caps at 10MB/record, 1GB total on Free)
- Webhook signatures verified (prevent unauthorized scenario execution)
- Environment variables secured (API keys, tokens in scenario settings, not hardcoded)
- Timeout values tuned (30s for OpenAI, 10s for databases, 60s for aggregators)
- Parallel execution tested (verify no race conditions in shared data stores)
Advanced scenarios require iterative testing with production-like data volumes. Run load tests with 100-1,000 concurrent executions to identify bottlenecks before launch.
Building Production-Grade ChatGPT Automation
Advanced Integromat scenarios transform ChatGPT applications from prototypes into resilient production systems. The patterns explored here—conditional routers, parallel processing, error handlers, data transformers, and rollback mechanisms—provide the automation foundation for scaling conversational AI to thousands of concurrent users.
Production deployment requires balancing execution speed (parallel processing), reliability (error handlers with retries), and cost efficiency (quota management). The seven IML implementations in this guide serve as templates for real-world ChatGPT workflows, from intent-based routing to multi-system atomic transactions.
Next Steps:
For teams building complex ChatGPT automation, start with conditional routers to handle basic intent classification, add error handlers with exponential backoff, then implement parallel processing for batch operations. As scenarios grow in complexity, refactor reusable logic into Make.com Custom Modules to improve maintainability.
Ready to Automate Your ChatGPT Application?
MakeAIHQ provides no-code tools for building ChatGPT applications with production-ready Integromat automation. Our visual scenario designer generates IML code automatically, implements error handling best practices, and deploys to the ChatGPT App Store in 48 hours—no manual scenario configuration required.
Start your free trial and build ChatGPT apps with advanced automation workflows that scale from prototype to production without writing a single line of IML code.